Fix: Install system dependencies as root before switching user

Dockerfile

@@ -1,10 +1,8 @@
 # Get a distribution that has uv already installed
 FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
 
-# Install required system dependencies for building packages (as root)
-RUN apt-get update && apt-get install -y gcc g++ python3-dev
-
 # Add user - this is the user that will run the app
+# If you do not set user, the app will run as root (undesirable)
 RUN useradd -m -u 1000 user
 USER user
 
@@ -20,14 +18,12 @@ WORKDIR $HOME/app
 # Copy the app to the container
 COPY --chown=user . $HOME/app
 
-# Copy dependencies separately
-COPY pyproject.toml .
-
-# Install dependencies
-RUN uv pip install --system --requirements pyproject.toml
+# Install the dependencies
+# RUN uv sync --frozen
+RUN uv sync
 
 # Expose the port
 EXPOSE 7860
 
 # Run the app
-CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,139 +1,193 @@
-import os
-from typing import List
-from chainlit.types import AskFileResponse
-from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
-from aimakerspace.openai_utils.prompts import (
-    UserRolePrompt,
-    SystemRolePrompt,
-    AssistantRolePrompt,
-)
-from aimakerspace.openai_utils.embedding import EmbeddingModel
-from aimakerspace.vectordatabase import VectorDatabase
-from aimakerspace.openai_utils.chatmodel import ChatOpenAI
+from typing import TypedDict, Annotated, List
+from typing_extensions import List, TypedDict
+
+from dotenv import load_dotenv
 import chainlit as cl
+import operator
+
+from langchain.prompts import ChatPromptTemplate
+from langchain.retrievers.contextual_compression import ContextualCompressionRetriever
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import DirectoryLoader, BSHTMLLoader, PyPDFLoader
+from sentence_transformers import SentenceTransformer
+from langchain_community.tools.arxiv.tool import ArxivQueryRun
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.documents import Document
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
+from langgraph.graph import START, StateGraph, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from langchain_core.prompts import PromptTemplate
+from langchain.embeddings import SentenceTransformerEmbeddings 
+from langchain_huggingface import HuggingFaceEmbeddings
+
+load_dotenv()
+
+openai_chat_model = ChatOpenAI(model="gpt-4o-mini")
+
+path = "data/"
+
+# Load HTML files
+html_loader = DirectoryLoader(path, glob="*.html", loader_cls=BSHTMLLoader)
+html_docs = html_loader.load()
+
+# Load PDF files
+pdf_loader = DirectoryLoader(path, glob="*.pdf", loader_cls=PyPDFLoader)
+pdf_docs = pdf_loader.load()
+
+# Combine both document lists
+docs = html_docs + pdf_docs
+
+# Split documents into chunks
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size = 850,
+    chunk_overlap  = 50,
+    length_function = len
+)
+split_documents =  text_splitter.split_documents(docs)
+
+
+# Load your fine-tuned model
+
+finetune_embeddings = HuggingFaceEmbeddings(model_name="finetuned_caregiver_ft")
+
+client = QdrantClient(":memory:")
+
+client.create_collection(
+    collection_name="ai_across_years2",
+    vectors_config=VectorParams(size=1024, distance=Distance.COSINE),
+)
+
+vector_store = QdrantVectorStore(
+    client=client,
+    collection_name="ai_across_years2",
+    embedding=finetune_embeddings,
+)
+
+_ = vector_store.add_documents(documents=split_documents)
+
+
+retriever = vector_store.as_retriever(search_kwargs={"k": 5})
+
+
+def retrieve(state):
+    retrieved_docs = retriever.invoke(state["question"])
+    return {"context": retrieved_docs}
 
-system_template = """\
-Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
-system_role_prompt = SystemRolePrompt(system_template)
 
-user_prompt_template = """\
-Context:
+#####
+
+RAG_template = """
+Use the following pieces of context to answer the question at the end.
+If you don't know the answer, just say "I don't know, would you like to talk to a care coach?", don't try to make up an answer.
+Use three sentences maximum and keep the answer as concise as possible.
+
 {context}
 
-Question:
-{question}
-"""
-user_role_prompt = UserRolePrompt(user_prompt_template)
+Question: {question}
 
-class RetrievalAugmentedQAPipeline:
-    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
-        self.llm = llm
-        self.vector_db_retriever = vector_db_retriever
+Helpful Answer:"""
 
-    async def arun_pipeline(self, user_query: str):
-        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
+rag_prompt = PromptTemplate.from_template(RAG_template) 
 
-        context_prompt = ""
-        for context in context_list:
-            context_prompt += context[0] + "\n"
+def generate(state):
+    docs_content = "\n\n".join([doc.page_content for doc in state["context"]])
+    messages = rag_prompt.format_prompt(context=docs_content, question=state["question"])
+    respose = openai_chat_model.invoke(messages)
+    return {"response": respose.content}
 
-        formatted_system_prompt = system_role_prompt.create_message()
+class State(TypedDict):
+  question: str
+  context: List[Document]
+  response: str
 
-        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+graph_builder = StateGraph(State).add_sequence([retrieve, generate])
+graph_builder.add_edge(START, "retrieve");
+graph = graph_builder.compile();
 
-        async def generate_response():
-            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
-                yield chunk
+@tool
+def ai_rag_tool(question: str) -> str:
+    """Answer questions about ALS based on the retrieved documents. Input should be a fully formed question."""
+    response = graph.invoke({"question": question})
+    return{
+        "messages": [HumanMessage(content=response["response"])],
+        "context": response["context"],
+    }
 
-        return {"response": generate_response(), "context": context_list}
+tavily_tool = TavilySearchResults(max_results=5)
 
-text_splitter = CharacterTextSplitter()
+tool_belt = [
+    tavily_tool,
+    ai_rag_tool,
+]
 
+model = ChatOpenAI(model="gpt-4o", temperature=0)
 
-def process_file(file: AskFileResponse):
-    import tempfile
-    import shutil
-    
-    print(f"Processing file: {file.name}")
-    
-    # Create a temporary file with the correct extension
-    suffix = f".{file.name.split('.')[-1]}"
-    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
-        # Copy the uploaded file content to the temporary file
-        shutil.copyfile(file.path, temp_file.name)
-        print(f"Created temporary file at: {temp_file.name}")
-        
-        # Create appropriate loader
-        if file.name.lower().endswith('.pdf'):
-            loader = PDFLoader(temp_file.name)
-        else:
-            loader = TextFileLoader(temp_file.name)
-            
-        try:
-            # Load and process the documents
-            documents = loader.load_documents()
-            texts = text_splitter.split_texts(documents)
-            return texts
-        finally:
-            # Clean up the temporary file
-            try:
-                os.unlink(temp_file.name)
-            except Exception as e:
-                print(f"Error cleaning up temporary file: {e}")
+model = model.bind_tools(tool_belt)
 
+class AgentState(TypedDict):
+  messages: Annotated[list, add_messages]
 
-@cl.on_chat_start
-async def on_chat_start():
-    files = None
+def call_model(state):
+    messages = state["messages"]
+    response = model.invoke(messages, config={"tool_choice": "auto"})  # Ensure it knows it can use tools
+    return {"messages": [response]}
 
-    # Wait for the user to upload a file
-    while files == None:
-        files = await cl.AskFileMessage(
-            content="Please upload a Text or PDF file to begin!",
-            accept=["text/plain", "application/pdf"],
-            max_size_mb=2,
-            timeout=180,
-        ).send()
+tool_node = ToolNode(tool_belt)
 
-    file = files[0]
+uncompiled_graph = StateGraph(AgentState)
 
-    msg = cl.Message(
-        content=f"Processing `{file.name}`..."
-    )
-    await msg.send()
+uncompiled_graph.add_node("agent", call_model)
+uncompiled_graph.add_node("action", tool_node)
 
-    # load the file
-    texts = process_file(file)
+uncompiled_graph.set_entry_point("agent")
 
-    print(f"Processing {len(texts)} text chunks")
+def should_continue(state):
+    last_message = state["messages"][-1]
+    print(f"Checking if model wants to call a tool: {last_message}")  # Debugging
 
-    # Create a dict vector store
-    vector_db = VectorDatabase()
-    vector_db = await vector_db.abuild_from_list(texts)
-    
-    chat_openai = ChatOpenAI()
+    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+        print(f"Model wants to call a tool: {last_message.tool_calls}")
+        return "action"
+
+    print("No tool calls detected, ending execution.")
+    return END
+
+
+### Add conditional edges to the graph
+uncompiled_graph.add_conditional_edges(
+    "agent",
+    should_continue
+)
+
+uncompiled_graph.add_edge("action", "agent")
+compiled_graph = uncompiled_graph.compile()
 
-    # Create a chain
-    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
-        vector_db_retriever=vector_db,
-        llm=chat_openai
-    )
-    
-    # Let the user know that the system is ready
-    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
-    await msg.update()
 
-    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
 
 
+@cl.on_chat_start
+async def start():
+  cl.user_session.set("compiled_graph", compiled_graph)
+
 @cl.on_message
-async def main(message):
-    chain = cl.user_session.get("chain")
+async def handle(message: cl.Message):
+    """Handle user messages, invoke the agent graph, and send responses."""
+    
+    compiled_graph = cl.user_session.get("compiled_graph")  # Retrieve the stored graph
+
+    # Initialize the state for the agent graph
+    state = {"messages": [HumanMessage(content=message.content)]}
 
-    msg = cl.Message(content="")
-    result = await chain.arun_pipeline(message.content)
+    # Invoke the agent graph asynchronously
+    response = await compiled_graph.ainvoke(state)
 
-    async for stream_resp in result["response"]:
-        await msg.stream_token(stream_resp)
+    # Extract the model's response and send it to the user
+    final_message = response["messages"][-1].content  # Extract last message content
 
-    await msg.send()
+    await cl.Message(content=final_message).send()

pyproject.toml

@@ -1,30 +1,31 @@
 [project]
 name = "midterm"
 version = "0.1.0"
-description = "midterm"
+description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "langchain>=0.2.0",
-    "langchain_openai",
-    "langchain_huggingface",
-    "langchain_core",
-    "langchain_community",
-    "langchain-text-splitters",
-    "faiss-cpu",
+    "arxiv==2.1.3",
+    "beautifulsoup4==4.13.3",
+    "chainlit==2.2.1",
+    "cohere==5.13.12",
+    "datasets==3.3.1",
+    "faiss-cpu==1.10.0",
+    "langchain-cohere==0.4.2",
+    "langchain-community==0.3.14",
+    "langchain-huggingface==0.1.2",
+    "langchain-openai==0.2.14",
+    "langchain-qdrant==0.2.0",
+    "langgraph==0.2.61",
+    "lxml==5.3.1",
+    "nltk==3.8.1",
+    "numpy==2.2.3",
+    "pyarrow==19.0.1",
+    "pymupdf==1.25.3",
+    "python-dotenv>=1.0.1",
     "python-pptx==1.0.2",
-    "nltk==3.9.1",
-    "pymupdf==1.25.2",
-    "beautifulsoup4",
-    "lxml",
-    "pypdf",
-    "wandb",
-    "accelerate>=0.26.0",
-    "langgraph==0.1.6",
-    "arxiv",
-    "langchain-qdrant==0.1.4",
-    "tiktoken",
-    "xmltodict",
-    "rapidfuzz",
-    "chainlit>=0.7.0"
-]
+    "ragas==0.2.10",
+    "sentence-transformers==3.4.1",
+    "unstructured==0.14.8",
+    "websockets>=15.0",
+]