add files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.11
+
+RUN apt-get update && apt-get install -y \
+    curl \
+    && curl -fsSL https://deb.nodesource.com/setup_lts.20.15.1| bash - \
+    && apt-get install -y nodejs \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN apt-get update && apt-get install -y npm
+
+# Verify installation
+RUN node --version
+RUN npm --version
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./backend/requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+
+USER root
+WORKDIR $HOME/app/frontend
+RUN npm install
+RUN npm audit fix
+RUN npm run build
+RUN chown -R user:user $HOME/app/frontend
+RUN chown -R user:user $HOME/app/backend
+USER user
+
+# Change back to app directory
+WORKDIR $HOME/app
+EXPOSE 5173
+EXPOSE 8080
+CMD ["/bin/bash", "-c", "./run.sh"]

README-orig.md

@@ -0,0 +1,16 @@
+---
+title: Chat Patient Intake
+emoji: 📚
+colorFrom: green
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+app_port: 5173
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+```
+
+```

README.md

@@ -1,11 +1,12 @@
 ---
-title: Aie4 Final
-emoji: 💻
-colorFrom: red
-colorTo: yellow
+title: Chat Patient Intake
+emoji: 📚
+colorFrom: green
+colorTo: indigo
 sdk: docker
 pinned: false
-short_description: Final Project
+license: mit
+app_port: 5173
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

backend/app/agents/medical.py

@@ -0,0 +1,55 @@
+import os
+from dotenv import load_dotenv
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langgraph.graph import END
+from .prompt import SYSTEM_PROMPT, CONTEXT_PROMPT, QUESTION_PROMPT
+load_dotenv()
+MODEL = os.getenv("MODEL")
+
+@tool
+def user_query(query:str):
+    """
+    Call this tool to retrieve the context of the conversation for the user's query which is an unambiguous and concise query with enough context from the message history.
+    """
+    return query
+
+@tool
+def completed(**kwargs):
+    """
+    Call this tool when allmedical questions have been completed.
+    """
+    return True
+
+tools_by_name = {
+    "user_query": user_query,
+    "completed": completed
+}
+
+def medical_route(state):
+    if not state["messages"]:
+        return END
+    last_message = state["messages"][-1]
+    if last_message.tool_calls:
+        return "rag_tool_node"
+    else:
+        return END
+    
+class MedicalQuestionAgent:
+    def __init__(self, questions=[]):
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", SYSTEM_PROMPT),
+            ("system", QUESTION_PROMPT),
+            ('system', CONTEXT_PROMPT),
+            MessagesPlaceholder(variable_name="messages")
+        ])
+        self.llm = ChatOpenAI(model=MODEL, temperature=0, streaming=True)
+        self.chain = self.prompt | self.llm.bind_tools([user_query, completed])
+        self.questions = questions
+        
+    def __call__(self, state):
+        results = self.chain.invoke({**state,  "questions": self.questions})
+        return {**state, "messages":[results] }
+    

backend/app/agents/prompt.py

@@ -0,0 +1,38 @@
+SYSTEM_PROMPT="""
+You are a helpful, empathetic and polite medical receptionist named Jane, assisting with basic administrative tasks. Introduce yourself as Jane in your first message and announce your purpose which is to obtain information from the patient for upcoming appointment. You are to be concise and be on track in obtaining information from the patient.  You are not a medical professional, so if a patient asks a medical question, you must politely remind them that you cannot provide medical advice or diagnoses. You should always encourage the patient to speak directly with their healthcare provider for medical concerns. You are to always ask the patient one question at a time and wait for the patient's response before asking the next question. Assume the patient has a high level of literacy and is able to understand and respond to your questions.
+"""
+
+
+VERIFICATION_PROMPT="""
+You are an expert in verification and validation. Given a list of fields, you are to retrieve information from the user for those fields. You also have the correct answers to these fields, allowing you to check if the user's responses are correct. You are not repeat the same question or ask a question that has already been asnwered by the user.
+
+For fields that involve dates:
+
+1. Parsing the Date: Accept the user's date input in any common format (e.g., "Jan 1 1990", "1st January 1990", "1990/01/01").
+2. Converting to ISO 8601 date format: Convert the parsed date into the yyyy-MM-dd format.
+3. Comparison: Compare the converted date with the correct answer you have.
+
+If the user's date input, after conversion, matches the correct answer, consider it correct. If not, proceed as follows:
+- Invalid Response Handling: Call the invalid tool without mentioning any correct values or hints.
+For non-date fields:
+
+- If the user's response is incorrect, call the 'invalid' tool with the value for the corresponding field you are verifying.
+
+Additional Guidelines:
+
+- Never reveal any of the correct answers to the user unless they have already provided that exact value.
+- If you have successfully verified all fields, call the 'completed' tool.
+- Never end with a farewell or goodbye.
+"""
+
+QUESTION_PROMPT = """\
+You are an expert in asking questions to the patient. You are to ask one question at a time and wait for the patient's response before asking the next question. You are not repeat the same question unless the user has not answered it correctly or fully. Once all questions are answered, call the 'completed' tool.
+
+QUESTIONS:
+{questions}
+
+"""
+
+CONTEXT_PROMPT = """\
+In addition to asking the patient questions, you are a friendly assistant that helps users answer their questions or responds to their comments. Only answer questions or respond to the comments with the context and message history. Do not make up information. Any query by the user that cannot be answered by you must call the 'user_query' function to retrieve the context for the user's query. Do not jump back to answering questions until you confirm that their questions have been answered if they did have questions or a query.
+"""

backend/app/agents/rag.py

@@ -0,0 +1,73 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langchain_openai import ChatOpenAI
+from operator import itemgetter
+from langchain.schema.runnable import RunnablePassthrough
+from .medical import tools_by_name
+
+SYSTEM_PROMPT = """\
+You are an expert in answering questions succintly and correctly only within context and chat history. Answer user's last question on the chat history and look at the message history for further context if needed. If you are not able to answer the last question of user based on the context reply with "I don't know". Never make up an answer.
+"""
+
+CONTEXT_PROMPT = """\
+Context:
+{context}
+
+Chat History:
+{chat_history}
+"""
+
+def map_messages(messages):
+    text=""
+    for message in messages:
+        if isinstance(message, HumanMessage):
+            text += f"Human: {message.content}\n"
+        elif isinstance(message, AIMessage):
+            text += f"AI: {message.content}\n"
+    return text
+
+class RAGTool:
+    def __init__(self, llm: ChatOpenAI, retriever:None):
+        self.retriever = retriever
+        self.llm = llm
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", SYSTEM_PROMPT),
+            ('user', CONTEXT_PROMPT)
+        ])
+
+        self.llm_chain = ({"context": itemgetter("question") | retriever, "chat_history": itemgetter("question")}
+                          | RunnablePassthrough.assign(context=itemgetter("context"))
+                          | {"response": self.prompt | self.llm, "context": itemgetter("context")}
+                          )
+        
+
+    def __call__(self, state):
+        last_message = state["messages"][-1]
+        messages = []
+        for tool_call in last_message.tool_calls:
+            print('TOOL CALL**********************',tools_by_name[tool_call["name"]],  tools_by_name[tool_call["name"]].invoke({**tool_call["args"]}))
+            if tool_call["name"] == "user_query":
+                query = tools_by_name[tool_call["name"]].invoke({**tool_call["args"]})
+                response = self.retriever.invoke(query)
+                print('RESPONSE**********************', response)
+                messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"], 
+                                            content=f"Context:\n{response}"))
+            elif tool_call["name"] == "completed":
+                state["next"]+=1
+                print("COMPLETED!!!!!", state["next"])
+                messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"],  content="Medical Intake complete. Tell the user or patient that we are done with the intake process. Give them a professional and friendly farewell and mention about looking forward to seeing them at the appointment."))
+            else:
+                messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"],  content=""))
+        
+        return {**state, "messages": messages}
+        
+        '''
+        user_input = state["question"]
+        result = self.llm_chain.invoke(
+            {"chat_history": map_messages(state["messages"])+f'Human: {user_input}'})
+        ai_message = result["response"]
+        context = result["context"]
+        return {**state, "messages": [ai_message], "context": context}
+        '''
+
+    

backend/app/agents/state/state.py

@@ -0,0 +1,28 @@
+from typing_extensions import TypedDict
+from typing import Annotated
+from langgraph.graph import add_messages
+
+class IdentificationState(TypedDict):
+    messages: Annotated[list, add_messages]
+    fields:str
+    values:str
+    counter:int
+    
+class IntakeRAGState(TypedDict):
+    messages: Annotated[list, add_messages]
+    question: str #current user input. It may or may not be a 'question'
+    context: str
+    
+class SupervisorState(TypedDict):
+    #messages: Annotated[list, add_messages]
+    next: str #next step in the workflow
+    
+class GraphState(TypedDict):
+    messages: Annotated[list, add_messages]
+    fields:str
+    values:str
+    counter:int
+    question: str #current user input. It may or may not be a 'question'
+    context: str
+    completed: str
+    next:int

backend/app/agents/supervisor.py

@@ -0,0 +1,22 @@
+from langgraph.graph import END
+class SupervisorAgent:
+    def __init__(self):
+        self.order = ['verification_agent', 'medical_agent']
+        self.next = 0
+    
+    def __call__(self, state):
+        if not state.get('completed'):
+            state["completed"] = ""
+        if not state.get('next'):
+            state["next"] = 0
+        if not state.get('context'):
+            state["context"] = ""
+            
+        return state
+
+    def route(self, state):
+        if self.next >= len(self.order):
+            return END
+        print("SUPERVISOR route", state["next"])
+        return self.order[state["next"]]
+        

backend/app/agents/verification.py

@@ -0,0 +1,86 @@
+import os
+from dotenv import load_dotenv
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+from langchain_core.messages import HumanMessage, ToolMessage
+from langgraph.graph import END
+from .prompt import VERIFICATION_PROMPT, SYSTEM_PROMPT
+load_dotenv()
+MODEL = os.getenv("MODEL")
+
+@tool
+def invalid(field:str, value:str, counter=1):
+    """
+    Call this tool if the user's response is not valid for one of the fields you are verifying.
+    """
+    if counter >= 2:
+        return f"The user's response for {field} with value {value} is not valid. Politely end the conversation and after ask them to call the support number."
+    else:
+        return f"The user's response for {field} with value {value} is not valid. Indicate to the user that it does not match our records. Please ask the user one more time."
+
+@tool
+def completed(**kwargs):
+    """
+    Call this tool when verification is complete and successful.
+    """
+    return "The verification is complete. Moving on to medical questions."
+
+tools_by_name = {
+    "invalid": invalid,
+    "completed": completed
+}
+
+def verification_route(state):
+    if not state["messages"]:
+        return END
+    last_message = state["messages"][-1]
+    if last_message.tool_calls:
+        return "verification_tool_node"
+    else:
+        return END
+
+class VerificationAgent:
+    def __init__(self):
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", SYSTEM_PROMPT),
+            ("system", VERIFICATION_PROMPT),
+            ("system", "Fields:{fields}"),
+            ("system", "Values:{values}"),
+            MessagesPlaceholder(variable_name="messages")
+        ])
+        self.llm = ChatOpenAI(model=MODEL, temperature=0, streaming=True)
+        self.chain = self.prompt | self.llm.bind_tools([invalid, completed])
+        
+    def __call__(self, state):
+        result = self.chain.invoke(state)
+        if not state.get("counter") or not result.tool_calls:
+            state["counter"] = 0
+        return {**state, "messages": [result]}
+    
+def process_tool(state): 
+    last_message = state["messages"][-1]
+    state["counter"] = state.get("counter")+1
+    #print('LAST MESSAGE**********************', last_message)
+    messages = []
+    for tool_call in last_message.tool_calls:
+
+        if tool_call["name"] == "invalid":
+            #print('TOOL CALL**********************', tools_by_name[tool_call["name"]].invoke({**tool_call["args"], "counter": state["counter"]}))
+            message = tools_by_name[tool_call["name"]].invoke({**tool_call["args"], "counter": state["counter"]})
+            if state["counter"] >= 2:
+                state["counter"] = 0
+                messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"], content=message))
+            else:
+                state["counter"] += 1
+                messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"],  content=f"The user's response for {tool_call['args']['field']} is not valid. Indicate to the user that it does not match our records. Please ask the user one more time."))
+        elif tool_call["name"] == "completed":
+            state["next"]+=1
+            print("COMPLETED!!!!!", state["next"])
+            messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"],  content="Verification complete. Prompt the user that we are moving on to medical questions. Do not end with a farwell. Mention that during the next stage the patient can ask any questions they have."))
+        else:
+            messages.append(ToolMessage(name=tool_call["name"], tool_call_id=tool_call["id"],  content=""))
+    return {**state, "messages": messages}
+        
+    
+    

backend/app/auth.py

@@ -0,0 +1,106 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from pydantic import BaseModel
+from datetime import datetime, timedelta, timezone
+import sqlite3
+import os
+
+SECRET_KEY = "your-secret-key"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 300
+
+pwd_context = CryptContext(schemes=["django_pbkdf2_sha256"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+auth_router = APIRouter()
+
+class User(BaseModel):
+    username: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+# SQLite setup
+DB_NAME = "users.db"
+
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    cur = conn.cursor()
+    cur.execute('''CREATE TABLE IF NOT EXISTS users
+                   (username TEXT PRIMARY KEY, hashed_password TEXT)''')
+    
+    # Add sample users if they don't exist
+    cur.execute("INSERT OR IGNORE INTO users VALUES (?, ?)", 
+                ("admin", pwd_context.hash("admin")))
+
+    
+    conn.commit()
+    conn.close()
+
+# Initialize the database
+init_db()
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_user(username: str):
+    conn = sqlite3.connect(DB_NAME)
+    cur = conn.cursor()
+    cur.execute("SELECT * FROM users WHERE username=?", (username,))
+    user = cur.fetchone()
+    conn.close()
+    if user:
+        return User(username=user[0])
+    return None
+
+def authenticate_user(username: str, password: str):
+    conn = sqlite3.connect(DB_NAME)
+    cur = conn.cursor()
+    cur.execute("SELECT * FROM users WHERE username=?", (username,))
+    user = cur.fetchone()
+    conn.close()
+    if not user:
+        return False
+    if not verify_password(password, user[1]):
+        return False
+    return User(username=user[0])
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+@auth_router.post("/token", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    user = authenticate_user(form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = create_access_token(data={"sub": user.username})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        user = get_user(username)
+        if user is None:
+            raise credentials_exception
+        return user
+    except JWTError:
+        raise credentials_exception

backend/app/chatbot.py

@@ -0,0 +1,5 @@
+from graph import run, graph
+
+if __name__ == "__main__":
+    app = graph.compile()
+    run(app)

backend/app/graph.py

@@ -0,0 +1,85 @@
+import os
+from langgraph.graph import StateGraph, END
+from langgraph.checkpoint.memory import MemorySaver
+# from .prompt import SYSTEM_PROMPT
+import asyncio
+from .agents.supervisor import SupervisorAgent
+from .agents.verification import VerificationAgent, process_tool, verification_route
+from .agents.medical import MedicalQuestionAgent, medical_route
+from .agents.rag import RAGTool
+from .agents.state.state import GraphState
+from data.preprocessing.vectorstore.get import retriever
+from langchain_openai import ChatOpenAI
+from .upload_pdf.ingest_documents import PDFProcessor
+
+
+pdf_processor = PDFProcessor(file_path=os.path.abspath(os.path.join(os.path.dirname(__file__), '..',  'data', 'combined_forms', 'temp', 'ACTC-Patient-Packet.pdf')))
+questions = pdf_processor.extract_questions()
+questions = [q.content for q in questions]
+print('QUESTIONS**********************', questions)
+memory = MemorySaver()
+
+graph = StateGraph(GraphState)
+
+supervisor = SupervisorAgent()
+graph.add_node("supervisor_agent", supervisor)
+graph.add_node("verification_agent", VerificationAgent())
+graph.add_node("verification_tool_node", process_tool)
+graph.add_node("medical_agent", MedicalQuestionAgent(questions=questions))
+graph.add_node("rag_tool_node", RAGTool(retriever=retriever,
+               llm=ChatOpenAI(model=os.environ["MODEL"])))
+
+graph.set_entry_point("supervisor_agent")
+
+graph.add_edge("verification_tool_node", "verification_agent")
+graph.add_edge("rag_tool_node", "medical_agent")
+graph.add_conditional_edges(
+    'supervisor_agent',
+     supervisor.route
+)
+graph.add_conditional_edges(
+    "verification_agent",
+    verification_route,
+    {"__end__": END, "verification_tool_node": "verification_tool_node"}
+)
+graph.add_conditional_edges(
+    "medical_agent",
+    medical_route,
+    {"__end__": END, "rag_tool_node": "rag_tool_node"}
+)
+
+
+async def run_verfication(app, fields="", values=""):
+    config = {"configurable": {"thread_id": 1}}
+
+    _input = input('User: ')
+    while _input != 'quit':
+        async for event in app.astream_events({"messages": [('user', _input)], "fields": "full name, birthdate", "values": "John Doe, 1990-01-01"}, config=config, version="v2"):
+            if event['event'] == "on_chat_model_stream":
+                data = event["data"]
+                if data["chunk"].content:
+                    print(data["chunk"].content.replace(
+                        "\n", ""), end="", flush=True)
+
+        _input = input('\nUser: ')
+
+
+async def run(app):
+    from langchain_core.messages import AIMessageChunk, HumanMessage
+    config = {"configurable": {"thread_id": 1}}
+    _user_input = input("User: ")
+
+    while _user_input != "quit":
+        out=""
+        astream = app.astream({"messages": [HumanMessage(content=_user_input)], "fields":"full name, birthdate", "values":"John Doe, 1990-01-01"}, config=config, stream_mode="messages")
+        async for msg, metadata in astream:
+            if isinstance(msg, AIMessageChunk):
+                out+=msg.content
+        print('Assistant: ', out)
+        _user_input = input("User: ")
+    
+
+if __name__ == "__main__":
+    app = graph.compile(checkpointer=memory)
+    asyncio.run(run(app))
+

backend/app/main.py

@@ -0,0 +1,22 @@
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .auth import auth_router
+from .webrtc import webrtc_router
+load_dotenv()
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(auth_router)
+app.include_router(webrtc_router)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8080)

backend/app/upload_pdf/ingest_documents.py

@@ -0,0 +1,83 @@
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain_community.vectorstores import Qdrant
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from dotenv import load_dotenv
+from .questions_agent import workflow
+load_dotenv()
+
+CHUNK_SIZE = 500
+CHUNK_OVERLAP = 200
+
+embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=CHUNK_SIZE,
+    chunk_overlap=CHUNK_OVERLAP
+)
+
+# Step 1: Parse the PDF and Extract Questions
+class PDFProcessor:
+    def __init__(self, file_path):
+        self.file_path = file_path
+        self.text = ""
+        self.docs = PyMuPDFLoader(self.file_path).load()
+
+    def extract_text(self): 
+        for doc in self.docs:
+            self.text += doc.page_content
+        return self.text
+
+    def extract_questions(self):
+        questions = []
+        chunks = text_splitter.split_text(self.extract_text())
+    
+        config = {"configurable":{"thread_id":1}}
+        #state = workflow.get_state(config=config).values
+        question_sets = workflow.batch(config=config, inputs=[{"context":chunk, "previous_questions":[]} for chunk in chunks])
+
+        for item in question_sets:
+            questions.extend(item.get("previous_questions", []))
+            
+        return questions
+
+
+# Step 2: Split Questions and Prepare for Vector Database
+class QuestionIngestor:
+    def __init__(self, questions):
+        self.questions = questions
+
+    def split_questions(self):
+        # Using a Text Splitter to handle long questions
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=20
+        )
+        docs = splitter.create_documents(self.questions)
+        return docs
+
+# Step 3: Setup Qdrant Vector Store and Index Data
+class QdrantSetup:
+    def __init__(self, questions):
+        self.questions = questions
+        self.qdrant_client = QdrantClient("localhost", port=6333)
+        self.embedding = OpenAIEmbeddings()
+
+    def setup_qdrant(self):
+        # Create a Qdrant collection for questions
+        self.qdrant_client.recreate_collection(
+            collection_name="questions",
+            vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
+        )
+
+    def index_questions(self):
+        # Index questions into Qdrant
+        qdrant_vectorstore = Qdrant(
+            client=self.qdrant_client,
+            collection_name="questions",
+            embedding=self.embedding
+        )
+        qdrant_vectorstore.add_documents(self.questions)
+# USE Parent Document Embedding for categorization

backend/app/upload_pdf/questions_agent.py

@@ -0,0 +1,49 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langgraph.graph import StateGraph
+from typing_extensions import Annotated, TypedDict
+from langgraph.graph import add_messages, END
+from langgraph.checkpoint.memory import MemorySaver
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm = ChatOpenAI(model="gpt-4o", temperature=0)
+memory = MemorySaver()
+
+class State(TypedDict):
+    previous_questions: Annotated[list, add_messages]
+    context:str
+
+prompt = ChatPromptTemplate.from_template(
+    """
+    You are an expert at ingesting documents and creating questions for a medical questionnaire to be answered by patients with a high school level education. Given the following context that should contain medical questions, and from only this context extract all medical questions separated by '|' that would be appropriate for a patient to answer. Indicate if the question is a multiple choice and the include the possible choices. If there are no medical questions in the context, output 'None'.
+
+    Context:
+    {context}
+    """
+)
+
+def create_questions(state):
+    results = (prompt | llm | StrOutputParser()).invoke(state)
+    questions = results.split("|")
+   
+    questions = [q for q in questions if q and q != 'None']
+    return {"previous_questions":questions, "context":state.get("context","") or ''}
+
+graph = StateGraph(State)
+
+graph.add_node("create_questions", create_questions)
+graph.set_entry_point("create_questions")
+graph.add_edge("create_questions", END)
+workflow = graph.compile(checkpointer=memory)
+
+
+
+
+
+
+
+

backend/app/webrtc.py

@@ -0,0 +1,83 @@
+import os
+from dotenv import load_dotenv
+from fastapi import APIRouter, Depends, WebSocket
+from fastapi.responses import JSONResponse
+from .auth import get_current_user
+from aiortc import RTCPeerConnection, RTCSessionDescription
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.memory import ConversationBufferMemory
+from langchain_core.messages import HumanMessage, RemoveMessage, AIMessageChunk
+from langgraph.checkpoint.memory import MemorySaver
+from .graph import graph
+from typing import Dict
+load_dotenv()
+
+memory = MemorySaver()
+app = graph.compile(checkpointer=memory)
+
+webrtc_router = APIRouter()
+
+# Initialize OpenAI
+llm = ChatOpenAI(temperature=0, model_name="gpt-4o")
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are expert in asking questions. Your goal is to ask full name, age, and address of a person."),
+    MessagesPlaceholder(variable_name="messages")
+])
+
+chain = prompt | llm #remove this
+user_memories: Dict[str, ConversationBufferMemory] = {} #remove this
+
+
+@webrtc_router.post("/webrtc/offer")
+async def webrtc_offer(offer: dict, current_user: dict = Depends(get_current_user)):
+    pc = RTCPeerConnection()
+    offer_obj = RTCSessionDescription(sdp=offer["sdp"], type=offer["type"])
+
+    await pc.setRemoteDescription(offer_obj)
+    answer = await pc.createAnswer()
+    await pc.setLocalDescription(answer)
+
+    # Create a new memory for the user if it doesn't exist
+    if current_user.username not in user_memories:
+        user_memories[current_user.username] = ConversationBufferMemory(
+            return_messages=True)
+
+    @pc.on("datachannel")
+    def on_datachannel(channel):
+        @channel.on("message")
+        async def on_message(message):
+            # Process the message using LangChain
+            memory = user_memories[current_user.username]
+            user_message = HumanMessage(content=message)
+
+            memory.chat_memory.add_user_message(user_message) #r
+
+            config = {"configurable": {"thread_id": current_user.username}}
+ 
+            astream = app.astream({"messages": [user_message], "fields":"full name, birthdate", "values":"John Doe, 1990-01-01"}, config=config, stream_mode="messages")
+            async for msg, metadata in astream:
+                if isinstance(msg, AIMessageChunk):
+                    channel.send(msg.content)
+                    
+    return JSONResponse(content={
+        "sdp": pc.localDescription.sdp,
+        "type": pc.localDescription.type
+    })
+
+
+@webrtc_router.post("/webrtc/ice-candidate")
+async def webrtc_ice_candidate(candidate: dict, current_user: dict = Depends(get_current_user)):
+    # In a real-world scenario, you'd store and forward this candidate to the other peer
+    return JSONResponse(content={"status": "success"})
+
+
+@webrtc_router.post("/webrtc/clear_memory")
+async def webrtc_clear_memory(obj: dict, current_user: dict = Depends(get_current_user)):
+    config = {"configurable": {"thread_id": current_user.username}}
+    state = app.get_state(config=config)
+    messages = state.values.get("messages", [])
+    for message in messages:
+        app.update_state(config, {"messages": RemoveMessage(id=message.id)})
+    return JSONResponse(content={"status": "success"})

backend/data/combined_forms/temp/ACTC-Patient-Packet.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a260c610ba55458698fb28200aa6b74273c462d94a3f253cd545b9036f97406f
+size 607119

backend/data/preprocessing/ingest_documents.py

@@ -0,0 +1,83 @@
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain_community.vectorstores import Qdrant
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from dotenv import load_dotenv
+from .questions_agent import workflow
+load_dotenv()
+
+CHUNK_SIZE = 500
+CHUNK_OVERLAP = 200
+
+embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=CHUNK_SIZE,
+    chunk_overlap=CHUNK_OVERLAP
+)
+
+# Step 1: Parse the PDF and Extract Questions
+class PDFProcessor:
+    def __init__(self, file_path):
+        self.file_path = file_path
+        self.text = ""
+        self.docs = PyMuPDFLoader(self.file_path).load()
+
+    def extract_text(self): 
+        for doc in self.docs:
+            self.text += doc.page_content
+        return self.text
+
+    def extract_questions(self):
+        questions = []
+        chunks = text_splitter.split_text(self.extract_text())
+    
+        config = {"configurable":{"thread_id":1}}
+        #state = workflow.get_state(config=config).values
+        question_sets = workflow.batch(config=config, inputs=[{"context":chunk, "previous_questions":[]} for chunk in chunks])
+
+        for item in question_sets:
+            questions.extend(item.get("previous_questions", []))
+            
+        return questions
+
+
+# Step 2: Split Questions and Prepare for Vector Database
+class QuestionIngestor:
+    def __init__(self, questions):
+        self.questions = questions
+
+    def split_questions(self):
+        # Using a Text Splitter to handle long questions
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=20
+        )
+        docs = splitter.create_documents(self.questions)
+        return docs
+
+# Step 3: Setup Qdrant Vector Store and Index Data
+class QdrantSetup:
+    def __init__(self, questions):
+        self.questions = questions
+        self.qdrant_client = QdrantClient("localhost", port=6333)
+        self.embedding = OpenAIEmbeddings()
+
+    def setup_qdrant(self):
+        # Create a Qdrant collection for questions
+        self.qdrant_client.recreate_collection(
+            collection_name="questions",
+            vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
+        )
+
+    def index_questions(self):
+        # Index questions into Qdrant
+        qdrant_vectorstore = Qdrant(
+            client=self.qdrant_client,
+            collection_name="questions",
+            embedding=self.embedding
+        )
+        qdrant_vectorstore.add_documents(self.questions)
+# USE Parent Document Embedding for categorization

backend/data/preprocessing/questions_agent.py

@@ -0,0 +1,49 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langgraph.graph import StateGraph
+from typing_extensions import Annotated, TypedDict
+from langgraph.graph import add_messages, END
+from langgraph.checkpoint.memory import MemorySaver
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm = ChatOpenAI(model="gpt-4o", temperature=0)
+memory = MemorySaver()
+
+class State(TypedDict):
+    previous_questions: Annotated[list, add_messages]
+    context:str
+
+prompt = ChatPromptTemplate.from_template(
+    """
+    You are an expert at ingesting documents and creating questions for a medical questionnaire to be answered by patients with a high school level education. Given the following context that should contain medical questions, and from only this context extract all medical questions separated by '|' that would be appropriate for a patient to answer. Indicate if the question is a multiple choice and the include the possible choices. If there are no medical questions in the context, output 'None'.
+
+    Context:
+    {context}
+    """
+)
+
+def create_questions(state):
+    results = (prompt | llm | StrOutputParser()).invoke(state)
+    questions = results.split("|")
+   
+    questions = [q for q in questions if q and q != 'None']
+    return {"previous_questions":questions, "context":state.get("context","") or ''}
+
+graph = StateGraph(State)
+
+graph.add_node("create_questions", create_questions)
+graph.set_entry_point("create_questions")
+graph.add_edge("create_questions", END)
+workflow = graph.compile(checkpointer=memory)
+
+
+
+
+
+
+
+