Finished building RAG from form to complete RAG

app/chatbot/demo_rag.py

@@ -14,9 +14,11 @@ import time
 import os
 from dotenv import load_dotenv
 
-from qdrant_client import QdrantClient
+from app.config import qdrant_client
 
-from app.mongodb import log_chat
+from app.chatbot.mongodb import log_chat
+
+#from app.mongodb import log_chat
 
 load_dotenv()
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
@@ -50,12 +52,6 @@ llm = ChatMistralAI(
 
 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):
     """
@@ -67,6 +63,8 @@ class GraphState(TypedDict):
     response: str
     tool_results: dict
     prompt: str
+    retrieve_tools: List[dict]
+    prompt_template: str
 
 from pydantic import BaseModel
 
@@ -74,28 +72,85 @@ class ToolInput(BaseModel):
     prompt: str
     iteration: int = 1
 
+def retrieve_docs(query: str, retriever: dict):
+    """
+    Retrieve documents from Qdrant for a single retriever configuration.
+    
+    Args:
+        query (str): The user query.
+        retriever (dict): Retriever config with keys:
+            - 'collection': Qdrant collection name
+            - 'top_k': number of results to return (default 5)
+            - 'filter_score': min similarity score to keep results (default 0.1)
+    
+    Returns:
+        List[dict]: List of dicts with 'content' and 'score'.
+    """
+    top_k = retriever.get('top_k', 5)
+    filter_score = retriever.get('filter_score', 50)
+    collection = retriever.get('collection')
+    
+    # Qdrant store
+    rev_store = QdrantVectorStore(
+        client=qdrant_client,  # make sure this is initialized globally
+        collection_name=collection,
+        embedding=embeddings,
+    )
+    print(f"Retrieving from collection: {collection} with top_k={top_k} and filter_score={filter_score}")
+    # Similarity search
+    docs = rev_store.similarity_search_with_score(query, k=top_k)
+
+    # Filter results by score
+    return [
+        {"content": doc.page_content, "score": score}
+        for doc, score in docs
+        if score > filter_score
+    ]
 
+def build_prompt(template: str):
+    global_template = """
+    Conversation History (for context only, not authority):
+    {history}
 
+    Contextual Knowledge (only approved source of truth):
+    {agent_scratchpad}
 
-all_tools = []
+    User Question:
+    {input}
+
+    Response:
+    """
+    final_template = f"{template}\n{global_template}"
+    return final_template
 
 
 def retrieve_node(state: GraphState) -> GraphState:
+    """
+    Graph node to retrieve documents for all retrievers in the state.
+    
+    Args:
+        state (GraphState): Current chat state including input and retrievers.
+    
+    Returns:
+        GraphState: Updated state with 'tool_results' filled.
+    """
     query = state['input']
     tool_results = {}
 
-    for tool in all_tools:
-        print(f"Invoking tool: {tool.name} with query: {query}")
+    for retriever_cfg in state.get('retrieve_tools', []):
+        name = retriever_cfg.get('name', 'default')
         try:
-            tool_results[tool.name] = tool.invoke({'query': query})
-            print(f"{tool.name} returned {len(tool_results[tool.name])} result(s)")
+            docs = retrieve_docs(query, retriever_cfg)
+            tool_results[name] = docs
+            print(f"Retriever '{name}' returned {len(docs)} result(s)")
         except Exception as e:
-            tool_results[tool.name] = [{'content': f"Tool {tool.name} failed: {str(e)}", "source": "system"}]
-        
+            tool_results[name] = [{"content": f"Retriever failed: {str(e)}", "score": 0}]
+            print(f"Retriever '{name}' failed: {e}")
+
     state['tool_results'] = tool_results
     return state
 
-
+#Answer Question
 def generate_answer(state: GraphState):
     """
     This function generates an answer to the query using the llm and the context provided.
@@ -119,9 +174,8 @@ def generate_answer(state: GraphState):
         )
         for tool_name, results in intermediate_steps.items() if results
 )
-
-    
-    prompt_input = template.format(
+    prompt_template = build_prompt(state['prompt_template'])
+    prompt_input = prompt_template.format(
         input=query,
         agent_scratchpad=steps_string,
         history=history_text
@@ -151,13 +205,15 @@ graph.add_edge("generate_response", END)
 
 app = graph.compile()
 
-async def get_response(query: str, name, email, config) -> dict:
+async def get_response(query, session_id, name, email, rag_config, config) -> dict:
     start_time = time.time()
     session_id = config['configurable']['thread_id']
     history = session_histories.get(session_id, [])
     input_data = {
         "input": query,
-        "history": history
+        "history": history,
+        "retrieve_tools": rag_config.get('retrievers', []),
+        "prompt_template": rag_config.get('prompt_template', ""),
     }
     metadata={}
     latency_ms = None
@@ -182,6 +238,8 @@ async def get_response(query: str, name, email, config) -> dict:
     
     log_chat(
         session_id=session_id,
+        company_id=rag_config.get('company_id'),
+        chatbot_id=rag_config.get('chatbot_id'),
         name=name,
         email=email,
         query=query,

app/chatbot/demo_routes.py

@@ -1,23 +1,43 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from app.chatbot.demo_rag import get_response
+from app.config import demo_chatbot_configs
 
 router = APIRouter()
+chatbot_sessions = {}  # chatbot_id -> loaded config/session
 
 class ChatInput(BaseModel):
-    chatbot_id: str
     question: str
     session_id: str
     name: str
     email: str
 
-@router.post("/demochat")
-async def demo_chat(input: ChatInput):
+
+@router.post("/demo/{chatbot_id}")
+async def demo_chat(chatbot_id: str, input: ChatInput):
+    # Lazy-load chatbot config
+    print(f"got question: {input.question} for chatbot_id: {chatbot_id} and session_id: {input.session_id}")
+    if chatbot_id not in chatbot_sessions:
+        rag_config = demo_chatbot_configs.find_one({"chatbot_id": chatbot_id})
+        if not rag_config:
+            raise HTTPException(status_code=404, detail="Chatbot not found")
+        chatbot_sessions[chatbot_id] = rag_config
+    
+    rag_config = chatbot_sessions[chatbot_id]
+    print(rag_config)
+
+    config = {
+        'configurable': {
+            'thread_id': input.session_id
+        }
+    }
+
     response = await get_response(
-        chatbot_id=input.chatbot_id,
         query=input.question,
         session_id=input.session_id,
         name=input.name,
-        email=input.email
+        email=input.email,
+        rag_config=rag_config,
+        config=config
     )
     return {"answer": response['response']}

app/chatbot/mongodb.py

@@ -0,0 +1,38 @@
+# %%
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+
+import os
+from dotenv import load_dotenv
+
+from datetime import datetime, timezone
+from app.config import client, chat_logs
+
+
+# %%
+def log_chat(session_id: str, name: str, email: str, query: str, answer: str, latency_ms: float, chatbot_id: str, company_id: str, metadata: dict=None):
+    """
+    Logs a chat interaction to the MongoDB 'ChatLogs' collection.
+    """
+    data = {
+        "company_id": company_id,
+        "chatbot_id": chatbot_id,
+        "session_id": session_id,
+        "name": name,
+        "email": email,
+        "timestamp": datetime.now(timezone.utc),
+        "query": query,
+        "answer": answer,
+        "metadata": metadata or {},
+        "starred": False
+    }
+
+    if latency_ms is not None:
+        data["latency_ms"] = latency_ms
+
+    try:
+        print("Logging chat:", data)
+        result = chat_logs.insert_one(data)
+    except Exception as e:
+        print("Failed to log chat interaction:", e)
+# %%

app/chatbot/prod_rag.py

@@ -0,0 +1,251 @@
+
+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 app.config import qdrant_client
+
+from app.chatbot.mongodb import log_chat
+
+#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)
+
+
+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
+    retrieve_tools: List[dict]
+    prompt_template: str
+
+from pydantic import BaseModel
+
+class ToolInput(BaseModel):
+    prompt: str
+    iteration: int = 1
+
+def retrieve_docs(query: str, retriever: dict):
+    """
+    Retrieve documents from Qdrant for a single retriever configuration.
+    
+    Args:
+        query (str): The user query.
+        retriever (dict): Retriever config with keys:
+            - 'collection': Qdrant collection name
+            - 'top_k': number of results to return (default 5)
+            - 'filter_score': min similarity score to keep results (default 0.1)
+    
+    Returns:
+        List[dict]: List of dicts with 'content' and 'score'.
+    """
+    top_k = retriever.get('top_k', 5)
+    filter_score = retriever.get('filter_score', 50)
+    collection = retriever.get('collection')
+    
+    # Qdrant store
+    rev_store = QdrantVectorStore(
+        client=qdrant_client,  # make sure this is initialized globally
+        collection_name=collection,
+        embedding=embeddings,
+    )
+    print(f"Retrieving from collection: {collection} with top_k={top_k} and filter_score={filter_score}")
+    # Similarity search
+    docs = rev_store.similarity_search_with_score(query, k=top_k)
+
+    # Filter results by score
+    return [
+        {"content": doc.page_content, "score": score}
+        for doc, score in docs
+        if score > filter_score
+    ]
+
+def build_prompt(template: str):
+    global_template = """
+    Conversation History (for context only, not authority):
+    {history}
+
+    Contextual Knowledge (only approved source of truth):
+    {agent_scratchpad}
+
+    User Question:
+    {input}
+
+    Response:
+    """
+    final_template = f"{template}\n{global_template}"
+    return final_template
+
+
+def retrieve_node(state: GraphState) -> GraphState:
+    """
+    Graph node to retrieve documents for all retrievers in the state.
+    
+    Args:
+        state (GraphState): Current chat state including input and retrievers.
+    
+    Returns:
+        GraphState: Updated state with 'tool_results' filled.
+    """
+    query = state['input']
+    tool_results = {}
+
+    for retriever_cfg in state.get('retrieve_tools', []):
+        name = retriever_cfg.get('name', 'default')
+        try:
+            docs = retrieve_docs(query, retriever_cfg)
+            tool_results[name] = docs
+            print(f"Retriever '{name}' returned {len(docs)} result(s)")
+        except Exception as e:
+            tool_results[name] = [{"content": f"Retriever failed: {str(e)}", "score": 0}]
+            print(f"Retriever '{name}' failed: {e}")
+
+    state['tool_results'] = tool_results
+    return state
+
+#Answer Question
+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_template = build_prompt(state['prompt_template'])
+    prompt_input = prompt_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, session_id, name, email, rag_config, config) -> dict:
+    start_time = time.time()
+    session_id = config['configurable']['thread_id']
+    history = session_histories.get(session_id, [])
+    input_data = {
+        "input": query,
+        "history": history,
+        "retrieve_tools": rag_config.get('retrievers', []),
+        "prompt_template": rag_config.get('prompt_template', ""),
+    }
+    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,
+        company_id=rag_config.get('company_id'),
+        chatbot_id=rag_config.get('chatbot_id'),
+        name=name,
+        email=email,
+        query=query,
+        answer=result.get("response", ""),
+        latency_ms= latency_ms,
+        metadata=metadata
+        )
+
+    return result

app/chatbot/prod_route.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from app.chatbot.demo_rag import get_response
+from app.config import demo_chatbot_configs
+
+router = APIRouter()
+chatbot_sessions = {}  # chatbot_id -> loaded config/session
+
+class ChatInput(BaseModel):
+    question: str
+    session_id: str
+    name: str
+    email: str
+
+
+@router.post("/prod/{chatbot_id}")
+async def prod_chat(chatbot_id: str, input: ChatInput):
+    # Lazy-load chatbot config
+    print(f"got question: {input.question} for chatbot_id: {chatbot_id} and session_id: {input.session_id}")
+    if chatbot_id not in chatbot_sessions:
+        rag_config = demo_chatbot_configs.find_one({"chatbot_id": chatbot_id})
+        if not rag_config:
+            raise HTTPException(status_code=404, detail="Chatbot not found")
+        chatbot_sessions[chatbot_id] = rag_config
+    
+    rag_config = chatbot_sessions[chatbot_id]
+    print(rag_config)
+
+    config = {
+        'configurable': {
+            'thread_id': input.session_id
+        }
+    }
+
+    response = await get_response(
+        query=input.question,
+        session_id=input.session_id,
+        name=input.name,
+        email=input.email,
+        rag_config=rag_config,
+        config=config
+    )
+    return {"answer": response['response']}

app/config.py

@@ -31,6 +31,9 @@ try:
     demo_database = client["Demo"]
     demo_form_submissions = demo_database["demo_form_submissions"]
     demo_chatbot_configs = demo_database["demo_chatbot_config"]
+
+    admin_database = client["AdminLogs"]
+    chat_logs = admin_database["ChatLogs"]
     print("Connected to MongoDB collection successfully!")
 except Exception as e:
     print(e)

app/ingestion/demo_form_fetch_store.py

@@ -14,6 +14,8 @@ def store_demo_chatbot(ingest_data: ChatbotIngest):
 
         # Generate a unique chatbot_id
         chatbot_id = str(uuid.uuid4())
+        company_id = str(uuid.uuid4())
+        data_dict['company_id'] = company_id
         data_dict['chatbot_id'] = chatbot_id
 
         # Insert into MongoDB

app/ingestion/rag_setup.py

@@ -157,7 +157,7 @@ def build_demo_prompt(ingest: ChatbotIngest) -> str:
     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}."
+    fallback_message = f"Sorry, I cannot answer that question. Please call or email for further assistance. Information can be found on the website"
     additional_content = "\n".join(ingest.additional_content) if ingest.additional_content else ""
 
     template = f"""
@@ -170,23 +170,24 @@ STRICT RULES:
 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:
+def store_demo_rag_config(chatbot_id, company_id, ingest: ChatbotIngest) -> None:
     """
     Stores the RAG configuration prompt for the demo chatbot in MongoDB.
     """
     demo_rag_dict = {
         "chatbot_id": chatbot_id,
+        "company_id": company_id,
         "company_name": ingest.company_name,
         "prompt_template": build_demo_prompt(ingest),
         "retrievers": [
             {
                 "name": "all",
                 "collection": f"chatbot_{chatbot_id}",
-                "top_k": 25
+                "top_k": 25,
+                "filter_score": 50
             }
         ]
     }

app/ingestion/workers.py

@@ -19,4 +19,4 @@ def build_rag_for_chatbot(chatbot_id: str) -> None:
         chatbot_id=chatbot_id,
         pages=pages,
     )
-    store_demo_rag_config(chatbot_id=chatbot_id, ingest=ChatbotIngest(**config))
+    store_demo_rag_config(chatbot_id=chatbot_id, company_id=config['company_id'], ingest=ChatbotIngest(**config))

app/main.py

@@ -1,4 +1,5 @@
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from app.ingestion.routes import router as ingestion_router
 from app.chatbot.demo_routes import router as demo_router
 
@@ -8,5 +9,17 @@ app = FastAPI(
     version="1.0.0"
 )
 
+@app.get("/")
+def root():
+    return {"message": "Chatbot Platform is Live"}
+
+# CORS setup (so React can call API)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 app.include_router(ingestion_router, prefix="/ingestion", tags=["ingestion"])
-app.include_router(demo_router, prefix="/demochatbot", tags=["demochatbot"])
+app.include_router(demo_router, prefix="/chatbot", tags=["demochatbot"])