Add RAG MCP Server with Supabase vector search

.gitignore

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

backend/api/mcp_clients/admin_client.py

@@ -0,0 +1,36 @@
+import os
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class AdminClient:
+    """
+    Communicates with the Admin MCP governance server.
+    """
+
+    def __init__(self):
+        self.base_url = os.getenv("ADMIN_MCP_URL")
+        self.alert_endpoint = f"{self.base_url}/alert"
+
+    async def alert(self, tenant_id: str, message: str, redflag: dict):
+        """
+        Sends redflag violation to admin server.
+        """
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    self.alert_endpoint,
+                    json={
+                        "tenant_id": tenant_id,
+                        "message": message,
+                        "violations": redflag.get("matches", []),
+                    }
+                )
+
+            return response.status_code == 200
+
+        except Exception as e:
+            print("Admin Client Error:", e)
+            return False

backend/api/mcp_clients/rag_client.py

@@ -0,0 +1,39 @@
+import os
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class RAGClient:
+    """
+    Communicates with the RAG MCP server.
+    """
+
+    def __init__(self):
+        self.base_url = os.getenv("RAG_MCP_URL")
+        self.search_endpoint = f"{self.base_url}/search"
+
+    async def search(self, query: str, tenant_id: str):
+        """
+        Sends the query to the RAG server and returns document chunks.
+        """
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    self.search_endpoint,
+                    json={
+                        "query": query,
+                        "tenant_id": tenant_id
+                    }
+                )
+
+            if response.status_code != 200:
+                return []
+
+            data = response.json()
+            return data.get("results", [])
+
+        except Exception as e:
+            print("RAG Client Error:", e)
+            return []

backend/api/mcp_clients/web_client.py

@@ -0,0 +1,38 @@
+import os
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class WebClient:
+    """
+    Communicates with the Web Search MCP server.
+    """
+
+    def __init__(self):
+        self.base_url = os.getenv("WEB_MCP_URL")
+        self.search_endpoint = f"{self.base_url}/search"
+
+    async def search(self, query: str):
+        """
+        Sends the query to the Web Search server and returns search results.
+        """
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    self.search_endpoint,
+                    json={
+                        "query": query
+                    }
+                )
+
+            if response.status_code != 200:
+                return []
+
+            data = response.json()
+            return data.get("results", [])
+
+        except Exception as e:
+            print("Web Client Error:", e)
+            return []

backend/api/routes/admin.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, Header, HTTPException
+from typing import List
+
+router = APIRouter()
+
+# Temporary in-memory store (replace with Supabase later)
+TENANT_RULES = {}
+
+
+def get_rules_for_tenant(tenant_id: str) -> List[str]:
+    return TENANT_RULES.get(tenant_id, [])
+
+
+@router.get("/admin/rules")
+async def get_redflag_rules(
+    x_tenant_id: str = Header(None)
+):
+    """
+    Returns all red-flag rules for this tenant.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    return {
+        "tenant_id": x_tenant_id,
+        "rules": get_rules_for_tenant(x_tenant_id)
+    }
+
+
+@router.post("/admin/rules")
+async def add_redflag_rule(
+    rule: str,
+    x_tenant_id: str = Header(None)
+):
+    """
+    Adds a new red-flag rule to this tenant.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    rules = get_rules_for_tenant(x_tenant_id)
+
+    if rule not in rules:
+        rules.append(rule)
+
+    TENANT_RULES[x_tenant_id] = rules
+
+    return {
+        "tenant_id": x_tenant_id,
+        "added_rule": rule,
+        "rules": rules
+    }
+
+
+@router.delete("/admin/rules/{rule}")
+async def delete_redflag_rule(
+    rule: str,
+    x_tenant_id: str = Header(None)
+):
+    """
+    Deletes a red-flag rule for this tenant.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    rules = get_rules_for_tenant(x_tenant_id)
+
+    if rule not in rules:
+        raise HTTPException(status_code=404, detail="Rule not found")
+
+    rules.remove(rule)
+    TENANT_RULES[x_tenant_id] = rules
+
+    return {
+        "tenant_id": x_tenant_id,
+        "deleted_rule": rule,
+        "rules": rules
+    }

backend/api/routes/agent.py

@@ -0,0 +1,30 @@
+from fastapi import APIRouter, Header, HTTPException
+from api.services.agent_orchestrator import AgentOrchestrator
+
+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"]
+    }

backend/api/routes/analytics.py

@@ -0,0 +1,103 @@
+from fastapi import APIRouter, Header, HTTPException
+
+router = APIRouter()
+
+# Mock in-memory analytics (replace with Supabase later)
+ANALYTICS_DATA = {
+    "tool_usage": {
+        "rag": 12,
+        "web": 8,
+        "admin": 3
+    },
+    "redflags": [
+        {
+            "tenant": "tenant123",
+            "match": "salary",
+            "message": "get salary data now",
+            "timestamp": "2025-01-14T10:22:00Z"
+        }
+    ],
+    "activity": {
+        "total_queries": 23,
+        "active_users": 4,
+        "last_query": "2025-01-14T10:24:31Z"
+    }
+}
+
+
+@router.get("/analytics/overview")
+async def analytics_overview(
+    x_tenant_id: str = Header(None)
+):
+    """
+    Returns an overview of analytics for the dashboard.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    return {
+        "tenant_id": x_tenant_id,
+        "overview": {
+            "total_queries": ANALYTICS_DATA["activity"]["total_queries"],
+            "tool_usage": ANALYTICS_DATA["tool_usage"],
+            "redflag_count": len(ANALYTICS_DATA["redflags"]),
+            "active_users": ANALYTICS_DATA["activity"]["active_users"]
+        }
+    }
+
+
+@router.get("/analytics/tool-usage")
+async def analytics_tool_usage(
+    x_tenant_id: str = Header(None)
+):
+    """
+    Returns how often each tool (RAG, Web, Admin) was used.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    return {
+        "tenant_id": x_tenant_id,
+        "tool_usage": ANALYTICS_DATA["tool_usage"]
+    }
+
+
+@router.get("/analytics/redflags")
+async def analytics_redflags(
+    x_tenant_id: str = Header(None)
+):
+    """
+    Returns red-flag violations for this tenant.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    redflags = [
+        r for r in ANALYTICS_DATA["redflags"]
+        if r["tenant"] == x_tenant_id
+    ]
+
+    return {
+        "tenant_id": x_tenant_id,
+        "redflags": redflags
+    }
+
+
+@router.get("/analytics/activity")
+async def analytics_activity(
+    x_tenant_id: str = Header(None)
+):
+    """
+    Returns general tenant activity statistics.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    return {
+        "tenant_id": x_tenant_id,
+        "activity": ANALYTICS_DATA["activity"]
+    }

backend/api/routes/rag.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, Header, HTTPException
+from api.mcp_clients.rag_client import RAGClient
+
+router = APIRouter()
+rag_client = RAGClient()
+
+
+@router.post("/rag/search")
+async def rag_search(
+    query: str,
+    x_tenant_id: str = Header(None)
+):
+    """
+    Search tenant knowledge base using the RAG MCP server.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    try:
+        results = await rag_client.search(query, x_tenant_id)
+        return {
+            "tenant_id": x_tenant_id,
+            "query": query,
+            "results": results
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/api/routes/web.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, Header, HTTPException
+from api.mcp_clients.web_client import WebClient
+
+router = APIRouter()
+web_client = WebClient()
+
+
+@router.post("/web/search")
+async def web_search(
+    query: str,
+    x_tenant_id: str = Header(None)
+):
+    """
+    Perform a live internet search using the Web MCP server.
+    """
+
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    try:
+        results = await web_client.search(query)
+        return {
+            "tenant_id": x_tenant_id,
+            "query": query,
+            "results": results
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/api/services/agent_orchestrator.py

@@ -0,0 +1,82 @@
+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
+
+from api.mcp_clients.rag_client import RAGClient
+from api.mcp_clients.web_client import WebClient
+from api.mcp_clients.admin_client import AdminClient
+
+
+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()
+
+        # MCP Tool Clients
+        self.rag_client = RAGClient()
+        self.web_client = WebClient()
+        self.admin_client = AdminClient()
+
+    async def process_message(self, user_message: str, tenant_id: str):
+        """
+        Main agent workflow for processing user input.
+        """
+
+        # 1. Intent
+        intent = self.intent_classifier.classify(user_message)
+
+        # 2. Red-Flag check
+        tenant_rules = []  # TODO: pull from database later
+        redflag = self.redflag_detector.check(user_message, tenant_rules)
+
+        # 3. Tool selection
+        tool = self.tool_selector.select_tool(intent, redflag)
+
+        # Tool outputs
+        rag_results = None
+        web_results = None
+
+        # 4. Execute selected tool (if any)
+        if tool == "rag":
+            rag_results = await self.rag_client.search(user_message, tenant_id)
+
+        elif tool == "web":
+            web_results = await self.web_client.search(user_message)
+
+        elif tool == "admin":
+            # Optional: notify admins
+            try:
+                await self.admin_client.alert(tenant_id, user_message, redflag)
+            except:
+                pass
+
+        # 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
+        )
+
+        # 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
+        }

backend/api/services/llm_client.py

@@ -1,13 +1,18 @@
+import os
 import requests
+from dotenv import load_dotenv
+
+load_dotenv()
 
 class LLMClient:
     """
     Uses a LOCAL Llama model via Ollama.
     """
 
-    def __init__(self, model="llama3"):
+    def __init__(self, model=os.getenv("OLLAMA_MODEL")):
         self.model = model
-        self.url = "http://localhost:11434/api/generate"
+        ollama_url = os.getenv("OLLAMA_URL")
+        self.url = f"{ollama_url}/api/generate"
 
     def generate(self, prompt: str) -> str:
         payload = {

backend/api/utils/text_extractor.py

@@ -0,0 +1,41 @@
+import re
+
+def extract_text(text: str, max_words: int = 300):
+    """
+    Split raw text into chunks of ~300 words.
+    Suitable for document ingestion before embeddings.
+
+    Args:
+        text (str): Raw text input
+        max_words (int): Max words per chunk (default 300)
+
+    Returns:
+        List[str]: List of chunked text segments
+    """
+
+    # Normalize whitespace
+    clean = re.sub(r'\s+', ' ', text).strip()
+
+    if not clean:
+        return []
+
+    words = clean.split(" ")
+    chunks = []
+
+    current = []
+    count = 0
+
+    for word in words:
+        current.append(word)
+        count += 1
+
+        if count >= max_words:
+            chunks.append(" ".join(current))
+            current = []
+            count = 0
+
+    # Add final chunk
+    if current:
+        chunks.append(" ".join(current))
+
+    return chunks

backend/mcp_servers/database.py

@@ -0,0 +1,203 @@
+"""
+Supabase database connection and utilities for MCP servers.
+
+This module provides both:
+1. Direct PostgreSQL connections (via psycopg2) for pgvector operations
+2. Supabase client for REST API operations
+"""
+
+import os
+from typing import Optional, List, Dict, Any
+import psycopg2
+import psycopg2.extras
+from supabase import create_client, Client
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# -----------------------------------
+# Environment variables
+# -----------------------------------
+
+DATABASE_URL = os.getenv("POSTGRESQL_URL")   # Direct PostgreSQL connection
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_SERVICE_KEY")   # MUST be service role key
+
+# Global Supabase client instance
+_supabase_client: Optional[Client] = None
+
+
+# -----------------------------------
+# PostgreSQL Connection (for pgvector)
+# -----------------------------------
+
+def get_connection():
+    """
+    Establish a direct PostgreSQL connection for pgvector operations.
+    """
+    if not DATABASE_URL:
+        raise ValueError(
+            "PostgreSQL connection string not configured. "
+            "Set POSTGRESQL_URL in your .env file."
+        )
+
+    return psycopg2.connect(DATABASE_URL)
+
+
+# -----------------------------------
+# Database Schema Initialization
+# -----------------------------------
+
+def initialize_database():
+    """
+    Initialize the database schema:
+    - Enable pgvector extension
+    - Create documents table with vector support
+    """
+    try:
+        conn = get_connection()
+        cur = conn.cursor()
+
+        # Enable pgvector extension
+        cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
+        print("✅ pgvector extension enabled")
+
+        # Create documents table
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS documents (
+                id BIGSERIAL PRIMARY KEY,
+                tenant_id TEXT NOT NULL,
+                chunk_text TEXT NOT NULL,
+                embedding vector(384) NOT NULL,
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+            );
+        """)
+        print("✅ documents table created")
+
+        # Create index for vector similarity search
+        cur.execute("""
+            CREATE INDEX IF NOT EXISTS documents_embedding_idx 
+            ON documents 
+            USING ivfflat (embedding vector_cosine_ops)
+            WITH (lists = 100);
+        """)
+        print("✅ vector index created")
+
+        # Create index for tenant_id for faster filtering
+        cur.execute("""
+            CREATE INDEX IF NOT EXISTS documents_tenant_id_idx 
+            ON documents (tenant_id);
+        """)
+        print("✅ tenant_id index created")
+
+        conn.commit()
+        cur.close()
+        conn.close()
+        print("✅ Database schema initialized successfully")
+
+    except Exception as e:
+        print(f"❌ Database initialization error: {e}")
+        # Don't raise - allow the app to continue even if table exists
+        if "already exists" not in str(e).lower():
+            raise
+
+
+# -----------------------------------
+# Document + Embedding Operations
+# -----------------------------------
+
+def insert_document_chunks(tenant_id: str, text: str, embedding: list):
+    """
+    Insert document chunk + embedding.
+    """
+    try:
+        conn = get_connection()
+        cur = conn.cursor()
+
+        cur.execute(
+            """
+            INSERT INTO documents (tenant_id, chunk_text, embedding)
+            VALUES (%s, %s, %s);
+            """,
+            (tenant_id, text, embedding)
+        )
+
+        conn.commit()
+        cur.close()
+        conn.close()
+
+    except Exception as e:
+        print("DB INSERT ERROR:", e)
+        raise
+
+
+def search_vectors(tenant_id: str, vector: list, limit: int = 5) -> List[str]:
+    """
+    Perform semantic vector search using pgvector.
+    """
+    try:
+        conn = get_connection()
+        cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
+
+        cur.execute(
+            """
+            SELECT
+                chunk_text,
+                1 - (embedding <=> %s::vector(384)) AS similarity
+            FROM documents
+            WHERE tenant_id = %s
+            ORDER BY embedding <=> %s::vector(384)
+            LIMIT %s;
+            """,
+            (vector, tenant_id, vector, limit)
+        )
+
+        rows = cur.fetchall()
+
+        cur.close()
+        conn.close()
+
+        return [row["chunk_text"] for row in rows]
+
+    except Exception as e:
+        print("DB SEARCH ERROR:", e)
+        return []
+
+
+# -----------------------------------
+# Supabase Client (for REST operations)
+# -----------------------------------
+
+def get_supabase_client() -> Client:
+    """
+    Get or create Supabase client.
+    """
+    global _supabase_client
+
+    if _supabase_client is None:
+        if not SUPABASE_URL or not SUPABASE_KEY:
+            raise ValueError(
+                "Supabase credentials missing. "
+                "Set SUPABASE_URL and SUPABASE_SERVICE_KEY."
+            )
+
+        _supabase_client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+    return _supabase_client
+
+
+def reset_client():
+    global _supabase_client
+    _supabase_client = None
+
+
+# Table names
+TABLES = {
+    "tenants": "tenants",
+    "documents": "documents",
+    "embeddings": "tenant_embeddings",
+    "redflag_rules": "redflag_rules",
+    "analytics": "analytics_events",
+    "tool_usage": "tool_usage_stats",
+}

backend/mcp_servers/embeddings.py

@@ -0,0 +1,17 @@
+from sentence_transformers import SentenceTransformer
+
+# Load MiniLM model (384-dimensional embeddings)
+model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+
+def embed_text(text: str):
+    """
+    Generate sentence embedding for use with pgvector.
+
+    Args:
+        text (str): Input text
+
+    Returns:
+        List[float]: 384-dimensional embedding vector
+    """
+    vector = model.encode(text)
+    return vector.tolist()

backend/mcp_servers/main.py

@@ -0,0 +1,172 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+import sys
+import os
+
+# --------------------------------------------------------
+# Fix Python module paths
+# --------------------------------------------------------
+
+current_dir = os.path.dirname(__file__)
+parent_dir = os.path.dirname(current_dir)
+
+sys.path.insert(0, current_dir)          # For embeddings + database
+sys.path.insert(0, os.path.join(parent_dir, "api"))  # For utils
+
+
+# --------------------------------------------------------
+# Imports AFTER adjusting paths
+# --------------------------------------------------------
+
+from embeddings import embed_text
+from database import insert_document_chunks, search_vectors, initialize_database
+from utils.text_extractor import extract_text
+
+
+# --------------------------------------------------------
+# Load environment variables
+# --------------------------------------------------------
+
+load_dotenv()
+
+
+# --------------------------------------------------------
+# FastAPI App
+# --------------------------------------------------------
+
+app = FastAPI(
+    title="RAG MCP Server",
+    description="Provides semantic search + ingestion for tenant knowledge bases",
+    version="1.0.0"
+)
+
+
+# --------------------------------------------------------
+# Enable CORS
+# --------------------------------------------------------
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# --------------------------------------------------------
+# Startup Event - Initialize Database
+# --------------------------------------------------------
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize database schema on server startup."""
+    try:
+        print("Initializing database schema...")
+        initialize_database()
+    except Exception as e:
+        print(f"Warning: Database initialization failed: {e}")
+        print("Server will continue, but database operations may fail.")
+
+
+# --------------------------------------------------------
+# Request Models
+# --------------------------------------------------------
+
+class IngestPayload(BaseModel):
+    tenant_id: str
+    content: str
+
+
+class SearchPayload(BaseModel):
+    query: str
+    tenant_id: str
+
+
+# --------------------------------------------------------
+# Health Check
+# --------------------------------------------------------
+
+@app.get("/")
+def root():
+    return {"status": "RAG MCP SERVER RUNNING"}
+
+
+# --------------------------------------------------------
+# Ingest Route
+# --------------------------------------------------------
+
+@app.post("/ingest")
+def ingest(payload: IngestPayload):
+    """
+    Ingest raw text:
+    - Chunk text
+    - Embed chunks
+    - Store in Postgres
+    """
+    try:
+        chunks = extract_text(payload.content)
+
+        if not chunks:
+            raise HTTPException(400, "No text found to ingest.")
+
+        inserted = 0
+
+        for chunk in chunks:
+            embedding = embed_text(chunk)
+            insert_document_chunks(payload.tenant_id, chunk, embedding)
+            inserted += 1
+
+        return {
+            "status": "ok",
+            "tenant_id": payload.tenant_id,
+            "chunks_stored": inserted
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --------------------------------------------------------
+# Search Route
+# --------------------------------------------------------
+
+@app.post("/search")
+def search(payload: SearchPayload):
+    """
+    Semantic search using pgvector + MiniLM embeddings.
+    """
+    try:
+        query_embedding = embed_text(payload.query)
+        results = search_vectors(payload.tenant_id, query_embedding, limit=5)
+
+        return {
+            "tenant_id": payload.tenant_id,
+            "query": payload.query,
+            "results": results
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --------------------------------------------------------
+# Allow "python main.py" to start server
+# --------------------------------------------------------
+
+if __name__ == "__main__":
+    import uvicorn
+
+    print("Starting RAG MCP Server on http://0.0.0.0:8001")
+    print("API Documentation: http://localhost:8001/docs")
+    print("Note: Reload mode disabled when running directly")
+
+    # Run the app directly (reload doesn't work with app object)
+    uvicorn.run(
+        app,  # Pass the app object directly
+        host="0.0.0.0",
+        port=8001,
+        reload=False  # Reload requires module path, not app object
+    )

backend/tests/test_agent_orchestrator.py

@@ -0,0 +1,21 @@
+import sys
+from pathlib import Path
+
+# Add backend directory to Python path
+backend_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(backend_dir))
+
+import asyncio
+from api.services.agent_orchestrator import AgentOrchestrator
+
+agent = AgentOrchestrator()
+
+async def run():
+    result = await agent.process_message(
+        "summarize our internal policy",
+        tenant_id="tenant123"
+    )
+    print(result["response"])
+    print("Tool used:", result["tool"])
+
+asyncio.run(run())

requirements.txt

@@ -1,3 +1,8 @@
 fastapi
 uvicorn
-requests
+requests
+httpx
+python-dotenv
+psycopg2
+supabase
+sentence-transformers