working the rag and web server

.gitignore

@@ -1,2 +1,3 @@
 venv/
-.env
+.env
+.pytest_cache

README.md

@@ -441,7 +441,7 @@ docker-compose up -d
 | **Category** | Enterprise |
 | **Tag** | `mcp-in-action-track-enterprise` |
 | **Project Name** | **IntegraChat** |
-
+  
 ### Short Summary
 
 > IntegraChat is a multi-tenant AI platform where autonomous MCP-powered agents retrieve private knowledge using RAG, access live web information, and enforce admin-defined safety rules via a red-flag compliance system. It includes an analytics dashboard, tool-selection engine, and strict tenant isolation.

backend/api/main.py

@@ -1,7 +1,28 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+import os
+import sys
+from pathlib import Path
 
-app = FastAPI()
+# ------------------------------------------------------------
+# Fix Python paths so imports like backend.api.routes.agent work
+# ------------------------------------------------------------
+root_dir = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(root_dir))
+
+# ------------------------------------------------------------
+# Import ALL routers correctly
+# ------------------------------------------------------------
+from backend.api.routes.agent import router as agent_router
+from backend.api.routes.admin import router as admin_router
+from backend.api.routes.rag import router as rag_router
+from backend.api.routes.web import router as web_router
+from backend.api.routes.analytics import router as analytics_router
+
+# ------------------------------------------------------------
+# Main FastAPI app
+# ------------------------------------------------------------
+app = FastAPI(title="IntegraChat API", version="1.0.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -11,6 +32,26 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# ------------------------------------------------------------
+# Route Registration (THIS FIXES YOUR 404)
+# ------------------------------------------------------------
+app.include_router(agent_router, prefix="/agent", tags=["Agent"])
+app.include_router(admin_router, prefix="/admin", tags=["Admin"])
+app.include_router(rag_router, prefix="/rag", tags=["RAG"])
+app.include_router(web_router, prefix="/web", tags=["Web"])
+app.include_router(analytics_router, prefix="/analytics", tags=["Analytics"])
+
+# ------------------------------------------------------------
+# Health Check
+# ------------------------------------------------------------
 @app.get("/health")
 def health():
     return {"status": "ok", "version": "1.0.0"}
+
+# ------------------------------------------------------------
+# Local Run
+# ------------------------------------------------------------
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("API_PORT", "8000"))
+    uvicorn.run("backend.api.main:app", host="0.0.0.0", port=port, reload=True)

backend/api/mcp_clients/mcp_client.py

@@ -0,0 +1,26 @@
+import httpx
+from dataclasses import dataclass, field
+
+
+@dataclass
+class MCPClient:
+    rag_url: str
+    web_url: str
+    admin_url: str
+    client: httpx.AsyncClient = field(default_factory=lambda: httpx.AsyncClient(timeout=30))
+
+
+    async def call_rag(self, tenant_id: str, query: str):
+        r = await self.client.post(f"{self.rag_url}/search", json={"tenant_id":tenant_id,"query":query})
+        return r.json()
+
+
+    async def call_web(self, tenant_id: str, query: str):
+        r = await self.client.post(f"{self.web_url}/search", json={"tenant_id":tenant_id,"query":query})
+        return r.json()
+
+
+    async def call_admin(self, tenant_id: str, query: str):
+        r = await self.client.post(f"{self.admin_url}/eval", json={"tenant_id":tenant_id,"query":query})
+        return r.json()
+

backend/api/models/__init__.py

@@ -0,0 +1,18 @@
+
+"""
+API Models Package
+
+This package contains all Pydantic and dataclass models used across the API.
+"""
+
+from .agent import AgentRequest, AgentDecision, AgentResponse
+from .redflag import RedFlagRule, RedFlagMatch
+
+__all__ = [
+    "AgentRequest",
+    "AgentDecision", 
+    "AgentResponse",
+    "RedFlagRule",
+    "RedFlagMatch",
+]
+

backend/api/models/agent.py

@@ -0,0 +1,24 @@
+from typing import Dict, Any, List
+from pydantic import BaseModel
+
+
+class AgentRequest(BaseModel):
+    tenant_id: str
+    user_id: str | None
+    message: str
+    conversation_history: List[Dict[str, str]] = []
+    temperature: float = 0.0
+
+
+class AgentDecision(BaseModel):
+    action: str
+    tool: str | None
+    tool_input: Dict[str, Any] | None
+    reason: str | None
+
+
+class AgentResponse(BaseModel):
+    text: str
+    decision: AgentDecision
+    tool_traces: List[Dict[str, Any]] = []
+

backend/api/models/redflag.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class RedFlagRule:
+    id: str
+    pattern: str
+    description: str
+    severity: str  # e.g., "low", "medium", "high", "critical"
+    source: str    # "admin", "system"
+    enabled: bool = True
+    keywords: List[str] = field(default_factory=list)
+
+
+@dataclass
+class RedFlagMatch:
+    rule_id: str
+    pattern: str
+    severity: str
+    description: str
+    matched_text: str
+

backend/api/routes/agent.py

@@ -1,30 +1,47 @@
-from fastapi import APIRouter, Header, HTTPException
+# =============================================================
+# File: backend/api/routes/agent.py
+# =============================================================
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+import os
+import sys
+from pathlib import Path
+
+# Add backend to path for imports
+backend_dir = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(backend_dir))
+
 from api.services.agent_orchestrator import AgentOrchestrator
+from api.models.agent import AgentRequest, AgentResponse
+
 
 router = APIRouter()
-agent = AgentOrchestrator()
-
-
-@router.post("/agent")
-async def agent_chat(
-    message: str,
-    x_tenant_id: str = Header(None)
-):
-    """
-    Main chat endpoint.
-    Frontend will call this to talk with the AI agent.
-    """
-
-    if not x_tenant_id:
-        raise HTTPException(status_code=400, detail="Missing tenant ID")
-
-    result = await agent.process_message(message, x_tenant_id)
-
-    return {
-        "response": result["response"],
-        "intent": result["intent"],
-        "tool": result["tool"],
-        "redflag": result["redflag"],
-        "rag_results": result["rag_results"],
-        "web_results": result["web_results"]
-    }
+
+
+orchestrator = AgentOrchestrator(
+    rag_mcp_url=os.getenv("RAG_MCP_URL", "http://localhost:8001"),
+    web_mcp_url=os.getenv("WEB_MCP_URL", "http://localhost:8002"),
+    admin_mcp_url=os.getenv("ADMIN_MCP_URL", "http://localhost:8003"),
+    llm_backend=os.getenv("LLM_BACKEND", "ollama")
+)
+
+
+class ChatRequest(BaseModel):
+    tenant_id: str
+    user_id: str | None = None
+    message: str
+    conversation_history: list[dict] = []
+    temperature: float = 0.0
+
+
+@router.post("/message", response_model=AgentResponse)
+async def agent_chat(req: ChatRequest):
+    agent_req = AgentRequest(
+        tenant_id=req.tenant_id,
+        user_id=req.user_id,
+        message=req.message,
+        conversation_history=req.conversation_history,
+        temperature=req.temperature
+    )
+    return await orchestrator.handle(agent_req)

backend/api/services/agent_orchestrator.py

@@ -1,82 +1,275 @@
-from api.services.intent_classifier import IntentClassifier
-from api.services.redflag_detector import RedFlagDetector
-from api.services.tool_selector import ToolSelector
-from api.services.prompt_builder import PromptBuilder
-from api.services.llm_client import LLMClient
+# =============================================================
+# File: backend/api/services/agent_orchestrator.py
+# =============================================================
+"""
+Agent Orchestrator (integrated with enterprise RedFlagDetector)
 
-from api.mcp_clients.rag_client import RAGClient
-from api.mcp_clients.web_client import WebClient
-from api.mcp_clients.admin_client import AdminClient
+Place at: backend/api/services/agent_orchestrator.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import List, Dict, Any, Optional
+
+from ..models.agent import AgentRequest, AgentDecision, AgentResponse
+from ..models.redflag import RedFlagMatch
+from .redflag_detector import RedFlagDetector
+from .intent_classifier import IntentClassifier
+from .tool_selector import ToolSelector
+from .llm_client import LLMClient
+from ..mcp_clients.mcp_client import MCPClient
 
 
 class AgentOrchestrator:
 
-    def __init__(self):
-        # Services
-        self.intent_classifier = IntentClassifier()
-        self.redflag_detector = RedFlagDetector()
-        self.tool_selector = ToolSelector()
-        self.prompt_builder = PromptBuilder()
-        self.llm_client = LLMClient()
+    def __init__(self, rag_mcp_url: str, web_mcp_url: str, admin_mcp_url: str, llm_backend: str = "ollama"):
+        self.mcp = MCPClient(rag_mcp_url, web_mcp_url, admin_mcp_url)
+        self.llm = LLMClient(backend=llm_backend, url=os.getenv("OLLAMA_URL"), api_key=os.getenv("GROQ_API_KEY"), model=os.getenv("OLLAMA_MODEL"))
+        
+        # pass admin_mcp_url so detector can call back
+        self.redflag = RedFlagDetector(
+            supabase_url=os.getenv("SUPABASE_URL"),
+            supabase_key=os.getenv("SUPABASE_SERVICE_KEY"),
+            admin_mcp_url=admin_mcp_url
+        )
+        
+        self.intent = IntentClassifier(llm_client=self.llm)
+        self.selector = ToolSelector(llm_client=self.llm)
 
-        # MCP Tool Clients
-        self.rag_client = RAGClient()
-        self.web_client = WebClient()
-        self.admin_client = AdminClient()
+    async def handle(self, req: AgentRequest) -> AgentResponse:
+        # 1) Red-flag check (async)
+        matches: List[RedFlagMatch] = await self.redflag.check(req.tenant_id, req.message)
 
-    async def process_message(self, user_message: str, tenant_id: str):
-        """
-        Main agent workflow for processing user input.
-        """
+        if matches:
+            # Notify admin asynchronously (do not await blocking the response path if you prefer)
+            # we await here to ensure admin receives the alert before responding
+            try:
+                await self.redflag.notify_admin(req.tenant_id, matches, source_payload={"message": req.message, "user_id": req.user_id})
+            except Exception:
+                pass
 
-        # 1. Intent
-        intent = self.intent_classifier.classify(user_message)
+            decision = AgentDecision(
+                action="block",
+                tool="admin",
+                tool_input={"violations": [m.__dict__ for m in matches]},
+                reason="redflag_triggered"
+            )
+            return AgentResponse(
+                text="Your request has been blocked due to policy.",
+                decision=decision,
+                tool_traces=[{"redflags": [m.__dict__ for m in matches]}]
+            )
 
-        # 2. Red-Flag check
-        tenant_rules = []  # TODO: pull from database later
-        redflag = self.redflag_detector.check(user_message, tenant_rules)
+        # 2) Intent classification
+        intent = await self.intent.classify(req.message)
 
-        # 3. Tool selection
-        tool = self.tool_selector.select_tool(intent, redflag)
+        # 2.5) Pre-fetch RAG results if available (for tool selector context)
+        rag_prefetch = None
+        rag_results = []
+        try:
+            # Try to pre-fetch RAG to help tool selector make better decisions
+            rag_prefetch = await self.mcp.call_rag(req.tenant_id, req.message)
+            if isinstance(rag_prefetch, dict):
+                rag_results = rag_prefetch.get("results") or rag_prefetch.get("hits") or []
+        except Exception:
+            # If RAG fails, continue without it
+            pass
 
-        # Tool outputs
-        rag_results = None
-        web_results = None
+        # 3) Tool selection (hybrid) - pass RAG results in context
+        ctx = {
+            "tenant_id": req.tenant_id,
+            "rag_results": rag_results
+        }
+        decision = await self.selector.select(intent, req.message, ctx)
 
-        # 4. Execute selected tool (if any)
-        if tool == "rag":
-            rag_results = await self.rag_client.search(user_message, tenant_id)
+        tool_traces: List[Dict[str, Any]] = []
 
-        elif tool == "web":
-            web_results = await self.web_client.search(user_message)
+        # 4) Handle multi-step tool execution
+        if decision.action == "multi_step" and decision.tool_input:
+            steps = decision.tool_input.get("steps", [])
+            if steps:
+                return await self._execute_multi_step(req, steps, decision, tool_traces, rag_prefetch)
 
-        elif tool == "admin":
-            # Optional: notify admins
+        # 5) Execute single tool
+        if decision.action == "call_tool" and decision.tool:
             try:
-                await self.admin_client.alert(tenant_id, user_message, redflag)
-            except:
-                pass
+                if decision.tool == "rag":
+                    rag_resp = await self.mcp.call_rag(req.tenant_id, decision.tool_input.get("query") if decision.tool_input else req.message)
+                    tool_traces.append({"tool": "rag", "response": rag_resp})
+                    prompt = self._build_prompt_with_rag(req, rag_resp)
+                    llm_out = await self.llm.simple_call(prompt, temperature=req.temperature)
+                    return AgentResponse(text=llm_out, decision=decision, tool_traces=tool_traces)
+
+                if decision.tool == "web":
+                    web_resp = await self.mcp.call_web(req.tenant_id, decision.tool_input.get("query") if decision.tool_input else req.message)
+                    tool_traces.append({"tool": "web", "response": web_resp})
+                    prompt = self._build_prompt_with_web(req, web_resp)
+                    llm_out = await self.llm.simple_call(prompt, temperature=req.temperature)
+                    return AgentResponse(text=llm_out, decision=decision, tool_traces=tool_traces)
+
+                if decision.tool == "admin":
+                    admin_resp = await self.mcp.call_admin(req.tenant_id, decision.tool_input.get("query") if decision.tool_input else req.message)
+                    tool_traces.append({"tool": "admin", "response": admin_resp})
+                    return AgentResponse(text=json.dumps(admin_resp), decision=decision, tool_traces=tool_traces)
 
-        # 5. Build prompt for LLM
-        prompt = self.prompt_builder.build(
-            user_message=user_message,
-            tool=tool,
-            rag_results=rag_results,
-            web_results=web_results,
-            redflag_info=redflag,
-            tenant_id=tenant_id
+                if decision.tool == "llm":
+                    llm_out = await self.llm.simple_call(req.message, temperature=req.temperature)
+                    return AgentResponse(text=llm_out, decision=decision)
+
+            except Exception as e:
+                tool_traces.append({"tool": decision.tool, "error": str(e)})
+                try:
+                    fallback = await self.llm.simple_call(req.message, temperature=req.temperature)
+                except Exception as llm_error:
+                    fallback = f"I encountered an error while processing your request: {str(e)}. Additionally, the AI service is unavailable: {str(llm_error)}"
+                return AgentResponse(
+                    text=fallback,
+                    decision=AgentDecision(action="respond", tool=None, tool_input=None, reason=f"tool_error_fallback: {e}"),
+                    tool_traces=tool_traces
+                )
+
+        # Default: direct LLM response
+        try:
+            llm_out = await self.llm.simple_call(req.message, temperature=req.temperature)
+        except Exception as e:
+            # If LLM fails, return a helpful error message
+            llm_out = f"I apologize, but I'm unable to process your request right now. The AI service is unavailable: {str(e)}"
+        
+        return AgentResponse(
+            text=llm_out,
+            decision=AgentDecision(action="respond", tool=None, tool_input=None, reason="default_llm")
         )
 
-        # 6. Call LLM
-        ai_response = self.llm_client.generate(prompt)
-
-        # 7. Return combined output
-        return {
-            "intent": intent,
-            "tool": tool,
-            "redflag": redflag,
-            "rag_results": rag_results,
-            "web_results": web_results,
-            "response": ai_response,
-            "prompt_used": prompt
-        }
+    def _build_prompt_with_rag(self, req: AgentRequest, rag_resp: Dict[str, Any]) -> str:
+        snippets = []
+        if isinstance(rag_resp, dict):
+            hits = rag_resp.get("results") or rag_resp.get("hits") or []
+            for h in hits[:5]:
+                txt = h.get("text") or h.get("content") or str(h)
+                snippets.append(txt)
+
+        snippet_text = "\n---\n".join(snippets) or ""
+        prompt = (
+            f"You are an assistant helping tenant {req.tenant_id}. Use the following retrieved documents to answer the user's question.\n"
+            f"Documents:\n{snippet_text}\n\n"
+            f"User question: {req.message}\nProvide a concise, accurate answer and cite the source snippets where appropriate."
+        )
+        return prompt
+
+    async def _execute_multi_step(self, req: AgentRequest, steps: List[Dict[str, Any]], 
+                                   decision: AgentDecision, tool_traces: List[Dict[str, Any]],
+                                   pre_fetched_rag: Optional[Dict[str, Any]] = None) -> AgentResponse:
+        """
+        Execute multiple tools in sequence and synthesize results with LLM.
+        """
+        rag_data = None
+        web_data = None
+        admin_data = None
+        collected_data = []
+
+        # Execute each step in sequence
+        for step_info in steps:
+            tool_name = step_info.get("tool")
+            step_input = step_info.get("input") or {}
+            query = step_input.get("query") or req.message
+
+            try:
+                if tool_name == "rag":
+                    # Reuse pre-fetched RAG if available, otherwise fetch
+                    if pre_fetched_rag:
+                        rag_resp = pre_fetched_rag
+                        tool_traces.append({"tool": "rag", "response": rag_resp, "note": "used_pre_fetched"})
+                    else:
+                        rag_resp = await self.mcp.call_rag(req.tenant_id, query)
+                        tool_traces.append({"tool": "rag", "response": rag_resp})
+                    rag_data = rag_resp
+                    # Extract snippets for prompt
+                    if isinstance(rag_resp, dict):
+                        hits = rag_resp.get("results") or rag_resp.get("hits") or []
+                        for h in hits[:5]:
+                            txt = h.get("text") or h.get("content") or str(h)
+                            collected_data.append(f"[RAG] {txt}")
+
+                elif tool_name == "web":
+                    web_resp = await self.mcp.call_web(req.tenant_id, query)
+                    tool_traces.append({"tool": "web", "response": web_resp})
+                    web_data = web_resp
+                    # Extract snippets for prompt
+                    if isinstance(web_resp, dict):
+                        hits = web_resp.get("results") or web_resp.get("items") or []
+                        for h in hits[:5]:
+                            title = h.get("title") or h.get("headline") or ""
+                            snippet = h.get("snippet") or h.get("summary") or h.get("text") or ""
+                            url = h.get("url") or h.get("link") or ""
+                            collected_data.append(f"[WEB] {title}\n{snippet}\nSource: {url}")
+
+                elif tool_name == "admin":
+                    admin_resp = await self.mcp.call_admin(req.tenant_id, query)
+                    tool_traces.append({"tool": "admin", "response": admin_resp})
+                    admin_data = admin_resp
+                    collected_data.append(f"[ADMIN] {json.dumps(admin_resp)}")
+
+                elif tool_name == "llm":
+                    # LLM is always last - synthesize all collected data
+                    break
+
+            except Exception as e:
+                tool_traces.append({"tool": tool_name, "error": str(e)})
+                # Continue with other tools even if one fails
+
+        # Build comprehensive prompt with all collected data
+        data_section = "\n---\n".join(collected_data) if collected_data else ""
+        
+        if data_section:
+            prompt = (
+                f"You are an assistant helping tenant {req.tenant_id}.\n\n"
+                f"The following information has been gathered from multiple sources:\n\n"
+                f"{data_section}\n\n"
+                f"User question: {req.message}\n\n"
+                f"Provide a comprehensive, accurate answer using the information above. "
+                f"Cite sources where appropriate (RAG for internal docs, WEB for online sources)."
+            )
+        else:
+            # No data collected, just answer the question
+            prompt = req.message
+
+        # Final LLM synthesis
+        try:
+            llm_out = await self.llm.simple_call(prompt, temperature=req.temperature)
+            return AgentResponse(
+                text=llm_out,
+                decision=decision,
+                tool_traces=tool_traces
+            )
+        except Exception as e:
+            tool_traces.append({"tool": "llm", "error": str(e)})
+            fallback = f"I encountered an error while synthesizing the response: {str(e)}"
+            return AgentResponse(
+                text=fallback,
+                decision=AgentDecision(
+                    action="respond",
+                    tool=None,
+                    tool_input=None,
+                    reason=f"multi_step_llm_error: {e}"
+                ),
+                tool_traces=tool_traces
+            )
+
+    def _build_prompt_with_web(self, req: AgentRequest, web_resp: Dict[str, Any]) -> str:
+        snippets = []
+        if isinstance(web_resp, dict):
+            hits = web_resp.get("results") or web_resp.get("items") or []
+            for h in hits[:5]:
+                title = h.get("title") or h.get("headline") or ""
+                snippet = h.get("snippet") or h.get("summary") or h.get("text") or ""
+                url = h.get("url") or h.get("link") or ""
+                snippets.append(f"{title}\n{snippet}\nSource: {url}")
+
+        snippet_text = "\n---\n".join(snippets) or ""
+        prompt = (
+            f"You are an assistant with access to recent web search results. Use the following results to answer.\n{snippet_text}\n\n"
+            f"User question: {req.message}\nAnswer succinctly and indicate which results you used."
+        )
+        return prompt

backend/api/services/intent_classifier.py

@@ -1,26 +1,35 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass
 class IntentClassifier:
-    def __init__(self):
-        self.rag_keywords = [
-            "internal", "document", "policy", "report", "knowledge",
-            "tenant", "kb", "file", "pdf", "doc", "summarize"
-        ]
+    intent_keywords: Dict[str, List[str]] = field(default_factory=lambda:{
+        "rag":["document","policy","manual","procedure","hr"],
+        "web":["latest","today","news","current","price","stock"],
+        "admin":["delete","remove","export","salary","confidential"],
+        "general":["explain","summary","help"]
+    })
+    llm_client: any = None
+
 
-        self.web_keywords = [
-            "news", "latest", "search", "google", "web",
-            "internet", "what is happening", "external"
-        ]
+    async def classify(self, text: str) -> str:
+        t = text.lower()
+        scores={k:0 for k in self.intent_keywords}
+        for k, words in self.intent_keywords.items():
+            for w in words:
+                if w in t: scores[k]+=1
+        best = max(scores, key=scores.get)
+        if scores[best] > 0: return best
 
-        self.admin_keywords = [ 
-            "delete", "remove", "salary", "confidential",
-            "admin", "shutdown", "disable", "breach"
-        ]
 
-    def classify(self, message: str) -> str:
-        if any(keyword in message.lower() for keyword in self.rag_keywords):
-            return "rag"
-        elif any(keyword in message.lower() for keyword in self.web_keywords):
-            return "web"
-        elif any(keyword in message.lower() for keyword in self.admin_keywords):
-            return "admin"
-        else:
-            return "general"
+        # LLM fallback with error handling
+        if self.llm_client:
+            try:
+                prompt=f"Classify into rag/web/admin/general. User: '{text}'"
+                out = (await self.llm_client.simple_call(prompt)).strip().lower()
+                return out if out in scores else "general"
+            except Exception:
+                # LLM failed (not configured or unavailable), default to general
+                return "general"
+        return "general"

backend/api/services/llm_client.py

@@ -1,30 +1,53 @@
-import os
-import requests
-from dotenv import load_dotenv
+import os, json
+import httpx
 
-load_dotenv()
 
 class LLMClient:
-    """
-    Uses a LOCAL Llama model via Ollama.
-    """
 
-    def __init__(self, model=os.getenv("OLLAMA_MODEL")):
-        self.model = model
-        ollama_url = os.getenv("OLLAMA_URL")
-        self.url = f"{ollama_url}/api/generate"
+    def __init__(self, backend="ollama", url=None, api_key=None, model=None):
+        self.backend = backend
+        self.url = url or os.getenv("OLLAMA_URL", "http://localhost:11434")
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        self.model = model or os.getenv("OLLAMA_MODEL", "llama3.1:latest")
+        self.http = httpx.AsyncClient(timeout=30)
 
-    def generate(self, prompt: str) -> str:
-        payload = {
-            "model": self.model,
-            "prompt": prompt,
-            "stream": False
-        }
 
-        try:
-            response = requests.post(self.url, json=payload)
-            data = response.json()
-            return data.get("response", "")
-
-        except Exception as e:
-            return f"⚠️ LOCAL LLM ERROR: {str(e)}"
+    async def simple_call(self, prompt: str, temperature: float = 0.0) -> str:
+        if self.backend=="ollama":
+            if not self.url or not self.model:
+                raise RuntimeError(f"LLM not configured: url={self.url}, model={self.model}. Set OLLAMA_URL and OLLAMA_MODEL env vars.")
+            
+            try:
+                # Ollama uses /api/generate endpoint
+                r = await self.http.post(
+                    f"{self.url}/api/generate",
+                    json={
+                        "model": self.model,
+                        "prompt": prompt,
+                        "stream": False,
+                        "options": {"temperature": temperature}
+                    }
+                )
+                r.raise_for_status()
+                response_data = r.json()
+                return response_data.get("response", "")
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 404:
+                    raise RuntimeError(
+                        f"Ollama endpoint not found. Is Ollama running at {self.url}? "
+                        f"Or does the model '{self.model}' exist? "
+                        f"Try: ollama pull {self.model}"
+                    )
+                elif e.response.status_code == 400:
+                    error_detail = e.response.json().get("error", "Unknown error")
+                    raise RuntimeError(f"Ollama API error: {error_detail}")
+                else:
+                    raise RuntimeError(f"Ollama API error: HTTP {e.response.status_code} - {e.response.text}")
+            except httpx.ConnectError:
+                raise RuntimeError(
+                    f"Cannot connect to Ollama at {self.url}. "
+                    f"Is Ollama running? Start it with: ollama serve"
+                )
+            except Exception as e:
+                raise RuntimeError(f"LLM call failed: {str(e)}")
+        raise RuntimeError("Unsupported backend")

backend/api/services/redflag_detector.py

@@ -1,54 +1,163 @@
+# =============================================================
+# File: backend/api/services/redflag_detector.py
+# =============================================================
+"""
+Enterprise RedFlagDetector
+
+- Loads per-tenant rules from Supabase REST (or you can swap to Postgres direct)
+- Caches rules per tenant with TTL
+- Performs regex and keyword matching
+- Returns structured match objects with severity and rule metadata
+- Sends notifications to Admin MCP or a webhook
+"""
+
+import os
 import re
+import time
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+import httpx
+
+from ..models.redflag import RedFlagRule, RedFlagMatch
+
 
 class RedFlagDetector:
-    def __init__(self):
-        # Built-in system red flags
-        self.core_flags = [
-            "delete all data",
-            "wipe database",
-            "salary",
-            "confidential",
-            "password",
-            "secret",
-            "credential",
-            "token",
-            "ssh key",
-            "api key"
-        ]
-
-        # Regex patterns for sensitive info
-        self.regex_patterns = {
-            "email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}",
-            "credit_card": r"\b(?:\d[ -]*?){13,16}\b",
-            "ssn": r"\b\d{3}-\d{2}-\d{4}\b",
-            "api_key": r"(?i)(apikey|api_key|token)[=:]\s?[A-Za-z0-9-_]{10,}"
-        }
 
-    def check(self, message: str, tenant_rules: list[str] = None) -> dict:
-        """
-        Returns a dictionary describing any red-flag detected.
-        """
-
-        message_lower = message.lower()
-        flags_detected = []
-
-        # 1. Built-in system flags
-        for keyword in self.core_flags:
-            if keyword in message_lower:
-                flags_detected.append(f"SystemFlag: {keyword}")
-
-        # 2. Tenant-defined rules
-        if tenant_rules:
-            for rule in tenant_rules:
-                if rule.lower() in message_lower:
-                    flags_detected.append(f"TenantFlag: {rule}")
-
-        # 3. Regex detection
-        for name, pattern in self.regex_patterns.items():
-            if re.search(pattern, message):
-                flags_detected.append(f"RegexMatch: {name}")
-
-        return {
-            "is_redflag": len(flags_detected) > 0,
-            "matches": flags_detected
+    def __init__(self, supabase_url: Optional[str] = None, supabase_key: Optional[str] = None, admin_mcp_url: Optional[str] = None, cache_ttl: int = 300):
+        self.supabase_url = supabase_url or os.getenv("SUPABASE_URL")
+        self.supabase_key = supabase_key or os.getenv("SUPABASE_SERVICE_KEY")
+        self.admin_mcp_url = admin_mcp_url or os.getenv("ADMIN_MCP_URL")
+        self.cache_ttl = cache_ttl
+        self._rules_cache: Dict[str, Dict[str, Any]] = {}  # tenant_id -> {"fetched_at":ts, "rules":[...]}
+        self._client = httpx.AsyncClient(timeout=15)
+
+    async def _fetch_rules_from_supabase(self, tenant_id: str) -> List[RedFlagRule]:
+        # Expecting a table `redflag_rules` with columns: id, tenant_id, pattern, description, severity, source, enabled, keywords (json array)
+        if not self.supabase_url or not self.supabase_key:
+            return []
+
+        url = self.supabase_url.rstrip("/") + "/rest/v1/redflag_rules"
+        headers = {"apikey": self.supabase_key, "Authorization": f"Bearer {self.supabase_key}"}
+        params = {"tenant_id": f"eq.{tenant_id}", "select": "*"}
+
+        r = await self._client.get(url, headers=headers, params=params)
+        r.raise_for_status()
+
+        rows = r.json()
+
+        rules: List[RedFlagRule] = []
+
+        for row in rows:
+            try:
+                keywords = row.get("keywords") or []
+                if isinstance(keywords, str):
+                    # attempt to parse JSON-encoded string
+                    try:
+                        import json
+                        keywords = json.loads(keywords)
+                    except Exception:
+                        keywords = []
+
+                rules.append(
+                    RedFlagRule(
+                        id=str(row.get("id")),
+                        pattern=row.get("pattern") or "",
+                        description=row.get("description") or "",
+                        severity=row.get("severity") or "medium",
+                        source=row.get("source") or "admin",
+                        enabled=row.get("enabled", True),
+                        keywords=keywords or [],
+                    )
+                )
+            except Exception:
+                # skip invalid rows defensively
+                continue
+
+        return rules
+
+    async def load_rules(self, tenant_id: str) -> List[RedFlagRule]:
+        now = int(time.time())
+        entry = self._rules_cache.get(tenant_id)
+
+        if entry and now - entry["fetched_at"] < self.cache_ttl:
+            return entry["rules"]
+
+        rules = await self._fetch_rules_from_supabase(tenant_id)
+        self._rules_cache[tenant_id] = {"fetched_at": now, "rules": rules}
+        return rules
+
+    async def check(self, tenant_id: str, text: str) -> List[RedFlagMatch]:
+        """Return structured matches for the given tenant and text."""
+        if not text:
+            return []
+
+        rules = await self.load_rules(tenant_id)
+        matches: List[RedFlagMatch] = []
+
+        text_lower = text.lower()
+
+        for rule in rules:
+            if not rule.enabled:
+                continue
+
+            matched = False
+            matched_text = ""
+
+            # 1) Keyword quick-check (cheap)
+            for kw in (rule.keywords or []):
+                if kw and kw.lower() in text_lower:
+                    matched = True
+                    matched_text = kw
+                    break
+
+            # 2) Regex check (more precise)
+            if not matched and rule.pattern:
+                try:
+                    pat = re.compile(rule.pattern, re.IGNORECASE)
+                    m = pat.search(text)
+                    if m:
+                        matched = True
+                        matched_text = m.group(0)
+                except re.error:
+                    # invalid regex; skip this rule
+                    continue
+
+            if matched:
+                matches.append(
+                    RedFlagMatch(
+                        rule_id=rule.id,
+                        pattern=rule.pattern,
+                        severity=rule.severity,
+                        description=rule.description,
+                        matched_text=matched_text,
+                    )
+                )
+
+        return matches
+
+    async def notify_admin(self, tenant_id: str, violations: List[RedFlagMatch], source_payload: Optional[Dict[str, Any]] = None) -> None:
+        """Notify the Admin MCP server (or a webhook) about the matches."""
+        payload = {
+            "tenant_id": tenant_id,
+            "violations": [v.__dict__ for v in violations],
+            "source": source_payload or {},
         }
+
+        # 1) POST to Admin MCP /alert if configured
+        if self.admin_mcp_url:
+            try:
+                await self._client.post(self.admin_mcp_url.rstrip("/") + "/alert", json=payload, timeout=10)
+            except Exception:
+                # swallow exceptions — notifications should not crash orchestration
+                pass
+
+        # 2) Optionally send to a Slack/Teams webhook
+        webhook = os.getenv("ALERT_WEBHOOK")
+        if webhook:
+            try:
+                await self._client.post(webhook, json={"text": f"Red-flag for tenant {tenant_id}", "details": payload}, timeout=10)
+            except Exception:
+                pass
+
+    async def close(self):
+        await self._client.aclose()

backend/api/services/tool_selector.py

@@ -1,27 +1,160 @@
+from dataclasses import dataclass, field
+import json
+import re
+
+
+@dataclass
 class ToolSelector:
-    """
-    Decides which MCP tool (if any) should be used by the agent.
-    """
-
-    def select_tool(self, intent: str, redflag: dict) -> str:
-        """
-        Returns one of:
-        - "admin"
-        - "rag"
-        - "web"
-        - "none"
-        """
-
-        # 1. Admin takes highest priority if any red-flag is present
-        if redflag.get("is_redflag", False):
-            return "admin"
-
-        # 2. Intent-based selection
-        if intent == "rag":
-            return "rag"
-
-        if intent == "web":
-            return "web"
-
-        # 3. Default
-        return "none"
+    llm_client: any = None
+
+
+    async def select(self, intent: str, text: str, ctx):
+        msg = text.lower().strip()
+
+        # ---------------------------------
+        # 1. Detect ADMIN RULES FIRST
+        # ---------------------------------
+        if intent == "admin":
+            return _multi_step([
+                step("admin", {"query": text}),
+                step("llm", {"query": text})
+            ], "admin safety rule triggered → llm")
+
+        steps = []
+        needs_rag = False
+        needs_web = False
+
+        # ---------------------------------
+        # 2. Check RAG results (pre-fetch)
+        # ---------------------------------
+        rag_results = ctx.get("rag_results", [])
+        rag_has_data = len(rag_results) > 0
+
+        # RAG patterns: internal knowledge, company-specific, documentation
+        rag_patterns = [
+            r"company", r"internal", r"documentation", r"our ", r"your ",
+            r"knowledge base", r"private", r"internal docs", r"corporate"
+        ]
+        if rag_has_data or any(re.search(p, msg) for p in rag_patterns):
+            needs_rag = True
+            if rag_has_data:
+                steps.append(step("rag", {"query": text}))
+
+        # ---------------------------------
+        # 3. Fact lookup / definition → Web
+        # ---------------------------------
+        fact_patterns = [
+            r"what is ", r"who is ", r"where is ",
+            r"tell me about ", r"define ", r"explain ",
+            r"history of ", r"information about", r"details about"
+        ]
+        if any(re.search(p, msg) for p in fact_patterns):
+            needs_web = True
+            steps.append(step("web", {"query": text}))
+
+        # ---------------------------------
+        # 4. Freshness heuristic → Web
+        # ---------------------------------
+        freshness_keywords = ["latest", "today", "news", "current", "recent", 
+                             "now", "updates", "breaking", "trending"]
+        if any(k in msg for k in freshness_keywords):
+            needs_web = True
+            # Avoid duplicate web steps
+            if not any(s["tool"] == "web" for s in steps):
+                steps.append(step("web", {"query": text}))
+
+        # ---------------------------------
+        # 5. Complex queries that need multiple sources
+        # ---------------------------------
+        complex_patterns = [
+            r"compare", r"difference between", r"versus", r"vs",
+            r"both", r"and also", r"as well as", r"in addition"
+        ]
+        needs_multiple = any(re.search(p, msg) for p in complex_patterns)
+
+        # ---------------------------------
+        # 6. Use LLM to enhance plan if we have partial steps or complex query
+        # ---------------------------------
+        if self.llm_client and (needs_multiple or (needs_rag and needs_web) or len(steps) == 0):
+            plan_prompt = f"""
+You are an enterprise MCP agent. 
+You can select MULTIPLE tools in sequence to provide comprehensive answers.
+
+TOOLS:
+- rag        → private knowledge retrieval (use for internal/company docs)
+- web        → online factual lookup (use for public facts, current info)
+- llm        → final reasoning and synthesis (always include at end)
+
+Current context:
+- RAG available: {rag_has_data}
+- User message: "{text}"
+
+Determine which tools are needed. You can select:
+- Just LLM (simple questions)
+- RAG + LLM (internal knowledge questions)
+- Web + LLM (public fact questions)
+- RAG + Web + LLM (comprehensive questions needing both sources)
+
+Return a JSON list describing the steps, e.g.:
+
+[
+  {{"tool": "rag", "reason": "Need internal documentation"}},
+  {{"tool": "web", "reason": "Need current public information"}},
+  {{"tool": "llm", "reason": "Synthesize all information"}}
+]
+
+Only return the JSON array. Do not include markdown formatting.
+"""
+            try:
+                out = await self.llm_client.simple_call(plan_prompt)
+                # Clean the output in case LLM adds markdown
+                out = out.strip()
+                if out.startswith("```json"):
+                    out = out[7:]
+                if out.startswith("```"):
+                    out = out[3:]
+                if out.endswith("```"):
+                    out = out[:-3]
+                out = out.strip()
+                
+                steps_json = json.loads(out)
+                
+                # Replace steps with LLM-planned steps (excluding LLM, we'll add it at end)
+                steps = [
+                    step(s["tool"], {"query": text})
+                    for s in steps_json if s.get("tool") != "llm"
+                ]
+            except Exception as e:
+                # If LLM planning fails, keep existing steps or use fallback
+                if not steps:
+                    steps = []
+
+        # ---------------------------------
+        # 7. Always end with LLM synthesis
+        # ---------------------------------
+        if not steps or steps[-1]["tool"] != "llm":
+            steps.append(step("llm", {
+                "rag_data": rag_results if rag_has_data else None,
+                "query": text
+            }))
+
+        # Build reason string showing the tool sequence
+        tool_names = [s["tool"] for s in steps]
+        reason = f"multi-tool plan: {' → '.join(tool_names)}"
+
+        return _multi_step(steps, reason)
+
+
+
+def step(tool, input_data):
+    return {"tool": tool, "input": input_data}
+
+
+def _multi_step(steps, reason):
+    from ..models.agent import AgentDecision
+    return AgentDecision(
+        action="multi_step",
+        tool=None,
+        tool_input={"steps": steps},
+        reason=reason
+    )

backend/mcp_servers/admin_server.py

@@ -0,0 +1,51 @@
+# =============================================================
+# File: backend/mcp_servers/admin_server.py
+# =============================================================
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+import sys
+import os
+
+# Fix Python module paths
+current_dir = os.path.dirname(__file__)
+sys.path.insert(0, current_dir)
+
+from models.admin import EvalRequest, AlertPayload
+
+
+admin_app = FastAPI(title="Admin MCP Server")
+
+# Enable CORS
+admin_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+log = logging.getLogger("admin_mcp")
+logging.basicConfig(level=logging.INFO)
+
+
+@admin_app.post("/eval")
+async def eval_query(req: EvalRequest):
+    danger = ["delete all data", "export users", "password", "token"]
+    q = req.query.lower()
+    for d in danger:
+        if d in q:
+            return {"action": "block", "reason": d}
+    return {"action": "allow"}
+
+
+@admin_app.post("/alert")
+async def alert(payload: AlertPayload):
+    log.warning(f"Alert received for tenant {payload.tenant_id}: {payload.violations}")
+    return {"status": "ok"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(admin_app, host="0.0.0.0", port=8003)

backend/mcp_servers/models/__init__.py

@@ -0,0 +1,18 @@
+"""
+MCP Server Models Package
+
+This package contains all Pydantic models used across MCP servers.
+"""
+
+from .admin import EvalRequest, AlertPayload
+from .rag import IngestRequest, SearchRequest
+from .web import WebSearchRequest
+
+__all__ = [
+    "EvalRequest",
+    "AlertPayload",
+    "IngestRequest",
+    "SearchRequest",
+    "WebSearchRequest",
+]
+

backend/mcp_servers/models/admin.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Optional
+
+
+class EvalRequest(BaseModel):
+    tenant_id: str
+    query: str
+
+
+class AlertPayload(BaseModel):
+    tenant_id: str
+    violations: list
+    source: Optional[dict] = None
+

backend/mcp_servers/models/rag.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class IngestRequest(BaseModel):
+    tenant_id: str
+    content: str
+
+
+class SearchRequest(BaseModel):
+    tenant_id: str
+    query: str
+

backend/mcp_servers/models/web.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class WebSearchRequest(BaseModel):
+    tenant_id: str
+    query: str
+

backend/mcp_servers/rag_server.py

@@ -0,0 +1,60 @@
+# =============================================================
+# File: backend/mcp_servers/rag_server.py
+# =============================================================
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import sys
+import os
+
+# Fix Python module paths
+current_dir = os.path.dirname(__file__)
+sys.path.insert(0, current_dir)
+
+from embeddings import embed_text
+from database import insert_document_chunks, search_vectors
+from models.rag import IngestRequest, SearchRequest
+
+
+rag_app = FastAPI(title="RAG MCP Server")
+
+# Enable CORS
+rag_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Wrapper functions to match expected interface
+def db_insert(tenant_id: str, content: str, vector: list):
+    """Wrapper for insert_document_chunks to match expected interface."""
+    return insert_document_chunks(tenant_id, content, vector)
+
+
+def db_search(tenant_id: str, vector: list, limit: int = 5):
+    """Wrapper for search_vectors to match expected interface."""
+    results = search_vectors(tenant_id, vector, limit)
+    return [{"text": text} for text in results]
+
+
+@rag_app.post("/ingest")
+async def ingest(req: IngestRequest):
+    vector = embed_text(req.content)
+    db_insert(req.tenant_id, req.content, vector)
+    return {"status": "ok"}
+
+
+@rag_app.post("/search")
+async def search(req: SearchRequest):
+    vector = embed_text(req.query)
+    results = db_search(req.tenant_id, vector)
+    return {"results": results}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(rag_app, host="0.0.0.0", port=8001)
+

backend/mcp_servers/web_server.py

@@ -0,0 +1,71 @@
+# =============================================================
+# File: backend/mcp_servers/web_server.py
+# =============================================================
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from duckduckgo_search import DDGS
+import sys
+import os
+
+# Fix Python module paths
+current_dir = os.path.dirname(__file__)
+sys.path.insert(0, current_dir)
+
+from models.web import WebSearchRequest
+
+web_app = FastAPI(title="Web Search MCP Server")
+
+# Enable CORS
+web_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@web_app.post("/search")
+async def web_search(req: WebSearchRequest):
+    """
+    Web search endpoint using DuckDuckGo.
+    Accepts tenant_id for multi-tenant support (currently not used but kept for API consistency).
+    Forces English language results by using region parameter and query modification.
+    """
+    try:
+        ddg = DDGS()
+        
+        # Modify query to prefer English results
+        # Add language hint to help get English content
+        query = req.query
+        # Only add language hint if not already present
+        if "lang:en" not in query.lower() and "site:en" not in query.lower():
+            query = f"{query} lang:en"
+        
+        # Try to use region parameter for English results
+        # Common region codes: 'us-en' for US English, 'uk-en' for UK English
+        try:
+            results = ddg.text(query, max_results=5, region='us-en')
+        except (TypeError, KeyError):
+            # If region parameter not supported, try without it
+            # The lang:en in query should still help
+            results = ddg.text(query, max_results=5)
+        
+        formatted = []
+        for r in results:
+            formatted.append({
+                "title": r.get("title"),
+                "snippet": r.get("body"),
+                "url": r.get("href"),
+            })
+
+        return {"results": formatted}
+
+    except Exception as e:
+        return {"error": str(e), "results": []}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(web_app, host="0.0.0.0", port=8002)

backend/tests/conftest.py

@@ -0,0 +1 @@
+

backend/tests/test_agent_orchestrator.py

@@ -1,3 +1,7 @@
+# =============================================================
+# File: tests/test_agent_orchestrator.py
+# =============================================================
+
 import sys
 from pathlib import Path
 
@@ -5,17 +9,212 @@ from pathlib import Path
 backend_dir = Path(__file__).parent.parent
 sys.path.insert(0, str(backend_dir))
 
-import asyncio
+try:
+    import pytest
+    HAS_PYTEST = True
+except ImportError:
+    HAS_PYTEST = False
+    # Create a mock pytest decorator if pytest is not available
+    class MockMark:
+        def asyncio(self, func):
+            return func
+    class MockPytest:
+        mark = MockMark()
+        def fixture(self, func):
+            return func
+    pytest = MockPytest()
+
+import os
 from api.services.agent_orchestrator import AgentOrchestrator
+from api.models.agent import AgentRequest, AgentDecision, AgentResponse
+from api.models.redflag import RedFlagMatch
+from api.services.llm_client import LLMClient
+
+
+# ---------------------------
+# Mock classes
+# ---------------------------
+
+class FakeLLM(LLMClient):
+    def __init__(self, output="LLM_RESPONSE"):
+        self.output = output
+
+    async def simple_call(self, prompt: str, temperature: float = 0.0):
+        return self.output
+
+
+class FakeMCP:
+    """Fake MCP server client used for rag/web/admin calls."""
+    def __init__(self):
+        self.last_rag = None
+        self.last_web = None
+        self.last_admin = None
+
+    async def call_rag(self, tenant_id: str, query: str):
+        self.last_rag = query
+        return {"results": [{"text": "RAG_DOC_CONTENT"}]}
+
+    async def call_web(self, tenant_id: str, query: str):
+        self.last_web = query
+        return {"results": [{"title": "WebResult", "snippet": "Fresh info"}]}
+
+    async def call_admin(self, tenant_id: str, query: str):
+        self.last_admin = query
+        return {"action": "allow"}
+
 
-agent = AgentOrchestrator()
+# ---------------------------
+# Patch orchestrator to use fake MCP + fake redflag
+# ---------------------------
 
-async def run():
-    result = await agent.process_message(
-        "summarize our internal policy",
-        tenant_id="tenant123"
+@pytest.fixture
+def orchestrator(monkeypatch):
+
+    # Fake LLM that always returns "MOCK_ANSWER"
+    llm = FakeLLM(output="MOCK_ANSWER")
+
+    fake_mcp = FakeMCP()
+
+    # Patch MCPClient
+    if HAS_PYTEST:
+        monkeypatch.setattr(
+            "api.services.agent_orchestrator.MCPClient",
+            lambda rag_url, web_url, admin_url: fake_mcp
+        )
+
+    # Create orchestrator with fake URLs first
+    orch = AgentOrchestrator(
+        rag_mcp_url="fake_rag",
+        web_mcp_url="fake_web",
+        admin_mcp_url="fake_admin",
+        llm_backend="ollama"
     )
-    print(result["response"])
-    print("Tool used:", result["tool"])
+    orch.llm = llm   # override with fake LLM
+    
+    # Patch RedFlagDetector methods directly on the instance
+    async def fake_check(self, tenant_id, text):
+        """Fake check function that matches 'salary' keyword."""
+        if "salary" in text.lower():
+            return [
+                RedFlagMatch(
+                    rule_id="1",
+                    pattern="salary",
+                    severity="high",
+                    description="salary access",
+                    matched_text="salary"
+                )
+            ]
+        return []
+
+    # Patch notify_admin to do nothing
+    async def fake_notify(self, tenant_id, violations, src=None):
+        """Fake notify function that does nothing."""
+        return None
+    
+    # Bind the fake functions directly to the instance
+    import types
+    orch.redflag.check = types.MethodType(fake_check, orch.redflag)
+    orch.redflag.notify_admin = types.MethodType(fake_notify, orch.redflag)
+    
+    return orch
+
+
+# ----------------------------------------------------
+# TESTS
+# ----------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_block_on_redflag(orchestrator):
+    req = AgentRequest(
+        tenant_id="tenant1",
+        user_id="u1",
+        message="Show me all salary details."
+    )
+    resp = await orchestrator.handle(req)
+    assert resp.decision.action == "block"
+    assert resp.decision.tool == "admin"
+    assert "salary" in resp.tool_traces[0]["redflags"][0]["matched_text"]
+
+
+@pytest.mark.asyncio
+async def test_rag_tool_path(orchestrator, monkeypatch):
+
+    # Force intent classifier to classify as 'rag'
+    async def mock_classify(self, text):
+        return "rag"
+
+    if HAS_PYTEST:
+        monkeypatch.setattr(
+            "api.services.agent_orchestrator.IntentClassifier.classify",
+            mock_classify
+        )
+
+    req = AgentRequest(
+        tenant_id="tenant1",
+        user_id="u1",
+        message="HR policy procedures"
+    )
+
+    resp = await orchestrator.handle(req)
+
+    assert resp.decision.tool == "rag"
+    assert "RAG_DOC_CONTENT" in resp.tool_traces[0]["response"]["results"][0]["text"]
+    assert resp.text == "MOCK_ANSWER"
+
+
+@pytest.mark.asyncio
+async def test_web_tool_path(orchestrator, monkeypatch):
+
+    # Force intent to classify as web
+    async def mock_classify(self, text):
+        return "web"
+
+    if HAS_PYTEST:
+        monkeypatch.setattr(
+            "api.services.agent_orchestrator.IntentClassifier.classify",
+            mock_classify
+        )
+
+    req = AgentRequest(
+        tenant_id="tenant1",
+        user_id="u1",
+        message="latest stock price"
+    )
+
+    resp = await orchestrator.handle(req)
+
+    assert resp.decision.tool == "web"
+    assert resp.text == "MOCK_ANSWER"
+
+
+@pytest.mark.asyncio
+async def test_default_llm_path(orchestrator, monkeypatch):
+
+    # Force intent = general and force tool selector to NOT call any tool
+    async def mock_select(self, intent, text, context):
+        from api.models.agent import AgentDecision
+        return AgentDecision(
+            action="respond",
+            tool=None,
+            tool_input=None,
+            reason="forced_llm"
+        )
+
+    if HAS_PYTEST:
+        monkeypatch.setattr(
+            "api.services.agent_orchestrator.ToolSelector.select",
+            mock_select
+        )
+
+    req = AgentRequest(
+        tenant_id="tenant1",
+        user_id="u1",
+        message="just a normal question"
+    )
+
+    resp = await orchestrator.handle(req)
 
-asyncio.run(run())
+    assert resp.decision.action == "respond"
+    assert resp.decision.tool is None
+    assert resp.text == "MOCK_ANSWER"

backend/tests/test_intent.py

@@ -1,3 +1,7 @@
+# =============================================================
+# File: tests/test_intent.py
+# =============================================================
+
 import sys
 from pathlib import Path
 
@@ -5,43 +9,110 @@ from pathlib import Path
 backend_dir = Path(__file__).parent.parent
 sys.path.insert(0, str(backend_dir))
 
+try:
+    import pytest
+    HAS_PYTEST = True
+except ImportError:
+    HAS_PYTEST = False
+    # Create a mock pytest decorator if pytest is not available
+    class MockMark:
+        def asyncio(self, func):
+            return func
+    class MockPytest:
+        mark = MockMark()
+    pytest = MockPytest()
+
+import asyncio
 from api.services.intent_classifier import IntentClassifier
 from api.services.llm_client import LLMClient
 from api.services.redflag_detector import RedFlagDetector
 from api.services.tool_selector import ToolSelector
-from api.services.prompt_builder import PromptBuilder
+from api.models.redflag import RedFlagMatch
+
+
+@pytest.mark.asyncio
+async def test_intent_rag_keywords():
+    classifier = IntentClassifier()
+    intent = await classifier.classify("Please check the HR policy document")
+    assert intent == "rag"
+
+@pytest.mark.asyncio
+async def test_intent_web_keywords():
+    classifier = IntentClassifier()
+    intent = await classifier.classify("latest news about Tesla stock")
+    assert intent == "web"
+
+@pytest.mark.asyncio
+async def test_intent_admin_keywords():
+    classifier = IntentClassifier()
+    intent = await classifier.classify("export all user data")
+    assert intent == "admin"
+
+@pytest.mark.asyncio
+async def test_intent_general():
+    classifier = IntentClassifier()
+    intent = await classifier.classify("explain how gravity works")
+    assert intent == "general"
 
-clf = IntentClassifier()
-detector = RedFlagDetector()
-selector = ToolSelector()
-builder = PromptBuilder()
-llm = LLMClient()
 
-print("RAG:", clf.classify("summarize internal policy"))
-print("WEB:", clf.classify("latest news about ai"))
-print("ADMIN:", clf.classify("delete all data"))
-print("GENERAL:", clf.classify("hi how are you"))
+# ---- LLM fallback test ----
 
+class FakeLLM:
+    async def simple_call(self, prompt: str, temperature: float = 0.0):
+        return "web"
 
-print(detector.check("My email is test@gmail.com"))
-print(detector.check("delete all data now"))
-print(detector.check("confidential salary report"))
-print(detector.check("hello world"))
+@pytest.mark.asyncio
+async def test_intent_llm_fallback():
+    classifier = IntentClassifier(llm_client=FakeLLM())
+    intent = await classifier.classify("What's going on in the world?")
+    assert intent == "web"
 
 
-print("admin:", selector.select_tool("web", {"is_redflag": True}))
-print("rag:", selector.select_tool("rag", {"is_redflag": False}))
-print("web:", selector.select_tool("web", {"is_redflag": False}))
-print("none:", selector.select_tool("general", {"is_redflag": False}))
+# ---- Manual run function (for non-pytest execution) ----
 
+async def run_manual_tests():
+    llm = LLMClient()
+    clf = IntentClassifier(llm_client=llm)
+    
+    # Initialize detector with empty creds (will return empty results if no Supabase)
+    import os
+    detector = RedFlagDetector(
+        supabase_url=os.getenv("SUPABASE_URL") or "",
+        supabase_key=os.getenv("SUPABASE_SERVICE_KEY") or ""
+    )
+    selector = ToolSelector(llm_client=llm)
 
-prompt = builder.build(
-    user_message="summarize this",
-    tool="rag",
-    rag_results=["Document text part 1", "Document text part 2"],
-    tenant_id="tenant123"
-)
+    print("Intent Classification:")
+    print("RAG:", await clf.classify("summarize internal policy"))
+    print("WEB:", await clf.classify("latest news about ai"))
+    print("ADMIN:", await clf.classify("delete all data"))
+    print("GENERAL:", await clf.classify("hi how are you"))
+    
+    print("\nRedFlag checks (will be empty if no Supabase configured):")
+    try:
+        print(await detector.check("tenant123", "My email is [email protected]"))
+        print(await detector.check("tenant123", "delete all data now"))
+        print(await detector.check("tenant123", "confidential salary report"))
+        print(await detector.check("tenant123", "hello world"))
+    except Exception as e:
+        print(f"RedFlag check failed (expected if Supabase not configured): {e}")
+    
+    print("\nTool selection:")
+    print(await selector.select("admin", "delete all data", {}))
+    print(await selector.select("rag", "summarize policy", {}))
+    print(await selector.select("web", "latest news", {}))
+    print(await selector.select("general", "hello", {}))
+    
+    print("\nLLM Test:")
+    try:
+        if llm.url and llm.model:
+            result = await llm.simple_call("Hello Llama!")
+            print(f"LLM Result: {result}")
+        else:
+            print("LLM not configured (OLLAMA_URL/OLLAMA_MODEL not set) - skipping LLM test")
+    except Exception as e:
+        print(f"LLM call failed (expected if Ollama not running or not configured): {e}")
 
-print(prompt)
 
-print(llm.generate("Hello Llama!"))
+if __name__ == "__main__":
+    asyncio.run(run_manual_tests())

env.example

@@ -0,0 +1,41 @@
+# =============================================================
+# IntegraChat Environment Variables Template
+# =============================================================
+# Copy this file to .env and fill in your actual values
+
+# =============================================================
+# SUPABASE CONFIGURATION
+# =============================================================
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_SERVICE_KEY=your_service_role_key_here
+POSTGRESQL_URL=postgresql://user:password@host:port/database
+
+# =============================================================
+# LLM CONFIGURATION
+# =============================================================
+# If using local Ollama
+OLLAMA_URL=http://localhost:11434
+OLLAMA_MODEL=llama3.1:latest
+
+# Backend selection (optional, defaults to "ollama")
+LLM_BACKEND=ollama
+
+# =============================================================
+# MCP SERVER URLs
+# =============================================================
+RAG_MCP_URL=http://localhost:8001
+WEB_MCP_URL=http://localhost:8002
+ADMIN_MCP_URL=http://localhost:8003
+
+# =============================================================
+# BACKEND CONFIG
+# =============================================================
+APP_ENV=development
+LOG_LEVEL=info
+API_PORT=8000
+
+# =============================================================
+# OPTIONAL: ALERTING
+# =============================================================
+# ALERT_WEBHOOK=https://hooks.slack.com/services/your/webhook/url
+

pytest.ini

@@ -0,0 +1,7 @@
+[pytest]
+asyncio_mode = auto
+testpaths = backend/tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+

requirements.txt

@@ -5,4 +5,7 @@ httpx
 python-dotenv
 psycopg2
 supabase
-sentence-transformers
+sentence-transformers
+pytest
+pytest-asyncio
+duckduckgo-search