added demo_config functionality

app/chatbot/demo_rag.py

@@ -0,0 +1,193 @@
+
+from typing import List, TypedDict
+
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+from langchain_core.tools import tool
+from langchain_core.runnables import RunnableLambda
+
+from langchain_qdrant import QdrantVectorStore
+from langchain_huggingface import HuggingFaceEmbeddings
+from langgraph.graph import StateGraph, END
+from langchain_mistralai import ChatMistralAI
+
+import time
+import os
+from dotenv import load_dotenv
+
+from qdrant_client import QdrantClient
+
+from app.mongodb import log_chat
+
+load_dotenv()
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+session_histories: dict[str, list] = {}
+
+LLM_MODEL = "mistral-medium-latest"
+OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY')
+COLLECTION_NAME = "chatbot_context"
+EMBEDDING_MODEL = "intfloat/e5-base-v2"
+QDRANT_URL = os.getenv('QDRANT_URL')
+QDRANT_API_KEY = os.getenv('QDRANT_API_KEY')
+SUPABASE_URL = os.getenv('SUPABASE_URL')
+SUPABASE_KEY = os.getenv('SUPABASE_KEY')
+MISTRAL_API_KEY = os.getenv('MISTRAL_API_KEY')
+
+FAQ_COLLECTION = "auro_faqs"
+BLOGS_COLLECTION = "auro_blogs"
+TECHNOLOGY_COLLECTION = "auro_technology"
+REVOLUTION_COLLECTION = "auro_revolution"
+SUPPORT_COLLECTION = "auro_support"
+PRODUCT_COLLECTION = "auro_product"
+
+
+
+llm = ChatMistralAI(
+    model_name=LLM_MODEL,
+    api_key=MISTRAL_API_KEY,
+)
+
+embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+
+try:
+    client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY)
+    print(f"Qdrant Collections: {client.get_collections()}")
+except Exception as e:
+    raise RuntimeError(f"Failed to connect to Qdrant: {e}")
+
+
+class GraphState(TypedDict):
+    """
+    Represents the state of a chat session, including input, output, history, memory,
+    response, tool results, and user role for LangGraph
+    """
+    input: str
+    history: List[BaseMessage] #list of past messages
+    response: str
+    tool_results: dict
+    prompt: str
+
+from pydantic import BaseModel
+
+class ToolInput(BaseModel):
+    prompt: str
+    iteration: int = 1
+
+
+
+
+all_tools = []
+
+
+def retrieve_node(state: GraphState) -> GraphState:
+    query = state['input']
+    tool_results = {}
+
+    for tool in all_tools:
+        print(f"Invoking tool: {tool.name} with query: {query}")
+        try:
+            tool_results[tool.name] = tool.invoke({'query': query})
+            print(f"{tool.name} returned {len(tool_results[tool.name])} result(s)")
+        except Exception as e:
+            tool_results[tool.name] = [{'content': f"Tool {tool.name} failed: {str(e)}", "source": "system"}]
+        
+    state['tool_results'] = tool_results
+    return state
+
+
+def generate_answer(state: GraphState):
+    """
+    This function generates an answer to the query using the llm and the context provided.
+    """    
+    query = state['input']
+    
+    history = state.get('history', [])
+    history_text = "\n".join(
+        f"Human: {m.content}" if isinstance(m, HumanMessage) else f"AI: {m.content}"
+        for m in history
+    )
+
+
+    intermediate_steps = state.get('tool_results', {})
+
+    steps_string = "\n".join(
+        f"{tool_name} Results:\n" +
+        "\n".join(
+            f"- Product: {entry.get('metadata', {}).get('product_name', 'N/A')}\n  {entry['content']}" 
+            for entry in results
+        )
+        for tool_name, results in intermediate_steps.items() if results
+)
+
+    
+    prompt_input = template.format(
+        input=query,
+        agent_scratchpad=steps_string,
+        history=history_text
+    )
+
+    print(prompt_input)
+    state['prompt'] = prompt_input
+
+    llm_response = llm.invoke(prompt_input)
+    state['response'] = llm_response.content if hasattr(llm_response, 'content') else str(llm_response)
+    state['history'].append(HumanMessage(content=query))
+    state['history'].append(AIMessage(content=state['response']))
+
+    return state
+
+
+graph = StateGraph(GraphState)
+
+#Add nodes to the graph
+graph.add_node("route_tool", RunnableLambda(retrieve_node))
+graph.add_node("generate_response", RunnableLambda(generate_answer))
+
+# Define the flow of the graph
+graph.set_entry_point("route_tool")
+graph.add_edge("route_tool", "generate_response")
+graph.add_edge("generate_response", END)
+
+app = graph.compile()
+
+async def get_response(query: str, name, email, config) -> dict:
+    start_time = time.time()
+    session_id = config['configurable']['thread_id']
+    history = session_histories.get(session_id, [])
+    input_data = {
+        "input": query,
+        "history": history
+    }
+    metadata={}
+    latency_ms = None
+    try:
+        result =  await app.ainvoke(input_data, config=config)
+        latency_ms = int((time.time() - start_time) * 1000)
+        session_histories[session_id] = result.get("history", [])
+    
+        metadata = {
+            "retrieved_docs": result.get("tool_results", {}),
+            "model": LLM_MODEL,
+            "embedding_model": EMBEDDING_MODEL,
+            "prompt": result.get("prompt", "")
+        }
+        filtered_result = result['response'].replace("transdermal", "topical")
+        result['response'] = filtered_result
+    except Exception as e:
+        result = {}
+        result['response'] = f"Error in processing chat: {e}"
+    
+    print(f"Response: {result['response']}")
+    
+    log_chat(
+        session_id=session_id,
+        name=name,
+        email=email,
+        query=query,
+        answer=result.get("response", ""),
+        latency_ms= latency_ms,
+        metadata=metadata
+        )
+
+    return result

app/chatbot/demo_routes.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from app.chatbot.demo_rag import get_response
+
+router = APIRouter()
+
+class ChatInput(BaseModel):
+    chatbot_id: str
+    question: str
+    session_id: str
+    name: str
+    email: str
+
+@router.post("/demochat")
+async def demo_chat(input: ChatInput):
+    response = await get_response(
+        chatbot_id=input.chatbot_id,
+        query=input.question,
+        session_id=input.session_id,
+        name=input.name,
+        email=input.email
+    )
+    return {"answer": response['response']}

app/config.py

@@ -30,6 +30,7 @@ try:
     
     demo_database = client["Demo"]
     demo_form_submissions = demo_database["demo_form_submissions"]
+    demo_chatbot_configs = demo_database["demo_chatbot_config"]
     print("Connected to MongoDB collection successfully!")
 except Exception as e:
     print(e)

app/ingestion/rag_setup.py

@@ -6,7 +6,7 @@ from collections import deque
 import tldextract
 from typing import List, Dict
 
-from app.config import qdrant_client, embedding_model
+from app.config import qdrant_client, embedding_model, demo_chatbot_configs
 
 from qdrant_client.models import VectorParams, Distance
 
@@ -16,6 +16,8 @@ from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_huggingface import HuggingFaceEmbeddings
 from qdrant_client import QdrantClient
 
+from app.ingestion.models import ChatbotIngest
+
 
 def scrape_website(
     start_url: str,
@@ -92,7 +94,7 @@ def scrape_website(
     return results
 
 
-def chunk_and_embed(chatbot_id: str, pages: List[Dict[str, str]], qdrant_client: QdrantClient):
+def chunk_and_embed(chatbot_id: str, pages: List[Dict[str, str]]):
     """
    Converts scraped website pages into embedded chunks and stores them in a chabot-scoped Qdrant Collection
     """
@@ -146,4 +148,51 @@ def chunk_and_embed(chatbot_id: str, pages: List[Dict[str, str]], qdrant_client:
     ids = [str(uuid4()) for _ in chunks]
     vector_store.add_documents(chunks, ids=ids)
 
-    print(f"Stored {len(chunks)} chunks in Qdrant collection {collection_name}")
+    print(f"Stored {len(chunks)} chunks in Qdrant collection {collection_name}")
+
+
+def build_demo_prompt(ingest: ChatbotIngest) -> str:
+    chatbot_name = ingest.chatbot_name or f"{ingest.company_name} Assistant"
+    company_name = ingest.company_name
+    allowed_topics = ", ".join(ingest.chatbot_purpose) or "general questions"
+    banned_topics = ingest.sensitive_topics or "sensitive topics"
+    response_style = ", ".join(ingest.tone_style) if ingest.tone_style else "clear and concise"
+    fallback_message = f"Sorry, I cannot answer that question. Please contact {ingest.contact_email} or call {ingest.contact_phone}."
+    additional_content = "\n".join(ingest.additional_content) if ingest.additional_content else ""
+
+    template = f"""
+You are {chatbot_name}, an assistant for {company_name}.
+Answer ONLY using the provided context from {company_name}'s approved content.
+
+STRICT RULES:
+1. If the Contextual Knowledge section is empty, say: "{fallback_message}"
+2. Do NOT use your own general knowledge. Only reference the Contextual Knowledge.
+3. Only reference topics explicitly allowed: {allowed_topics}.
+4. Do NOT discuss banned topics: {banned_topics}.
+5. Keep responses {response_style}.
+6. Additional context to consider: {additional_content}
+"""
+    return template
+
+def store_demo_rag_config(chatbot_id, ingest: ChatbotIngest) -> None:
+    """
+    Stores the RAG configuration prompt for the demo chatbot in MongoDB.
+    """
+    demo_rag_dict = {
+        "chatbot_id": chatbot_id,
+        "company_name": ingest.company_name,
+        "prompt_template": build_demo_prompt(ingest),
+        "retrievers": [
+            {
+                "name": "all",
+                "collection": f"chatbot_{chatbot_id}",
+                "top_k": 25
+            }
+        ]
+    }
+    result = demo_chatbot_configs.insert_one(demo_rag_dict)
+    print(f"Inserted RAG config for {ingest.company_name}, _id={result.inserted_id}")
+
+
+
+

app/ingestion/workers.py

@@ -1,8 +1,7 @@
 # workers.py
 from app.ingestion.demo_form_fetch_store import get_chatbot_config
-from app.ingestion.rag_setup import scrape_website
-from app.ingestion.rag_setup import chunk_and_embed
-from app.config import qdrant_client
+from app.ingestion.models import ChatbotIngest
+from app.ingestion.rag_setup import scrape_website, chunk_and_embed, store_demo_rag_config
 
 
 def build_rag_for_chatbot(chatbot_id: str) -> None:
@@ -19,5 +18,5 @@ def build_rag_for_chatbot(chatbot_id: str) -> None:
     chunk_and_embed(
         chatbot_id=chatbot_id,
         pages=pages,
-        qdrant_client=qdrant_client,
     )
+    store_demo_rag_config(chatbot_id=chatbot_id, ingest=ChatbotIngest(**config))

app/main.py

@@ -1,5 +1,6 @@
 from fastapi import FastAPI
 from app.ingestion.routes import router as ingestion_router
+from app.chatbot.demo_routes import router as demo_router
 
 app = FastAPI(
     title="Chatbot Platform - Demo Ingestion",
@@ -7,5 +8,5 @@ app = FastAPI(
     version="1.0.0"
 )
 
-# Mount ingestion routes
 app.include_router(ingestion_router, prefix="/ingestion", tags=["ingestion"])
+app.include_router(demo_router, prefix="/demochatbot", tags=["demochatbot"])