rag app

.gitignore

@@ -1 +1,4 @@
-myenv
+myenv
+*pycache*
+
+

Dockerfile

@@ -1,20 +0,0 @@
-FROM python:3.12
-# Create a new user named 'user' with user ID 1000 and create their home directory
-RUN useradd -m -u 1000 user
-# Switch to the newly created user
-USER user
-# Add the user's local bin directory to the PATH
-ENV PATH="/home/user/.local/bin:$PATH"
-# Set the working directory in the container to /app
-WORKDIR /app
-# Copy the requirements.txt file from the host to the container
-# The --chown=user ensures the copied file is owned by our 'user'
-# RUN --mount=type=secret,id=HF_TOKEN,mode=0444,required=true
-COPY --chown=user ./requirements.txt requirements.txt
-# Install the Python dependencies listed in requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-# Copy the rest of the application code from the host to the container
-# Again, ensure the copied files are owned by 'user'
-COPY --chown=user . /app
-# Specify the command to run when the container starts
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,9 +1,5 @@
 from fastapi import FastAPI
-
 app = FastAPI()
-
 @app.get("/")
-def api_get():
-    return {"Hello": "World"}
-
-
+def greet_json():
+    return {"Hello": "World!"}

app/Backend/Dockerfile

@@ -1,20 +0,0 @@
-FROM python:3.12
-# Create a new user named 'user' with user ID 1000 and create their home directory
-RUN useradd -m -u 1000 user
-# Switch to the newly created user
-USER user
-# Add the user's local bin directory to the PATH
-ENV PATH="/home/user/.local/bin:$PATH"
-# Set the working directory in the container to /app
-WORKDIR /app
-# Copy the requirements.txt file from the host to the container
-# The --chown=user ensures the copied file is owned by our 'user'
-RUN --mount=type=secret,id=HF_TOKEN,mode=0444,required=true
-COPY --chown=user ./requirements.txt requirements.txt
-# Install the Python dependencies listed in requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-# Copy the rest of the application code from the host to the container
-# Again, ensure the copied files are owned by 'user'
-COPY --chown=user . /app
-# Specify the command to run when the container starts
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app/Backend/app.py

@@ -1,5 +0,0 @@
-from fastapi import FastAPI
-app = FastAPI()
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}

app/Backend/requirements.txt

@@ -1,9 +0,0 @@
-fastapi
-uvicorn[standard]
-sse-starlette
-langchain-core
-langserve
-sqlalchemy
-langchain-huggingface
-transformers
-

app/Frontend/README.md

@@ -1,12 +0,0 @@
----
-title: Frontend
-emoji: 🚀
-colorFrom: indigo
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.37.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/Frontend/app.py

@@ -1,12 +0,0 @@
-import streamlit as st
-
-pg = st.navigation([
-    st.Page("pages/simple_page.py"), 
-    st.Page("pages/formatted_page.py"),
-    st.Page("pages/history_page.py"), 
-    st.Page("pages/rag_page.py"),
-    st.Page("pages/filtered_rag_page.py"),
-])
-pg.run()
-
-

app/Frontend/pages/filtered_rag_page.py

@@ -1,9 +0,0 @@
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-from pages.page_base import chat_interface
-
-
-chat_title = "Filtered RAG Chat App"
-url = "[YOUR FILTERED RAG URL]"
-page_hash = get_script_run_ctx().page_script_hash
-
-chat_interface(chat_title, page_hash, url)

app/Frontend/pages/formatted_page.py

@@ -1,9 +0,0 @@
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-from pages.page_base import chat_interface
-
-
-chat_title = "Formatted Chat App"
-url = "[YOUR FORMATTED CHAT URL]"
-page_hash = get_script_run_ctx().page_script_hash
-
-chat_interface(chat_title, page_hash, url)

app/Frontend/pages/history_page.py

@@ -1,9 +0,0 @@
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-from pages.page_base import chat_interface
-
-
-chat_title = "History Chat App"
-url = "[YOUR HISTORY CHAT URL]"
-page_hash = get_script_run_ctx().page_script_hash
-
-chat_interface(chat_title, page_hash, url)

app/Frontend/pages/page_base.py

@@ -1,48 +0,0 @@
-import streamlit as st
-from langserve.client import RemoteRunnable
-
-def get_response(user_input, url, username):
-    response_placeholder = st.empty()
-    full_response = ""
-    chain = RemoteRunnable(url)
-    stream = chain.stream(input={'question': user_input, 'username': username})
-    for chunk in stream:
-        full_response += chunk
-        response_placeholder.markdown(full_response)
-
-    return full_response
-
-def chat_interface(chat_title, page_hash ,url):
-    st.title(chat_title)
-
-    # Add username input at the top of the page
-    username = st.text_input("Enter your username:", key="username_input", value="Guest")
-
-    # Initialize page-specific chat history
-    if "chat_histories" not in st.session_state:
-        st.session_state.chat_histories = {}
-    
-    if page_hash not in st.session_state.chat_histories:
-        st.session_state.chat_histories[page_hash] = []
-
-    # Display chat messages from history for the current page
-    for message in st.session_state.chat_histories[page_hash]:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-
-    # React to user input
-    if prompt := st.chat_input("What is your message?"):
-        # Display user message in chat message container
-        st.chat_message("user").markdown(prompt)
-        # Add user message to chat history
-        st.session_state.chat_histories[page_hash].append({"role": "user", "content": prompt})
-
-        # Get streaming response
-        with st.chat_message("assistant"):
-            full_response = get_response(prompt, url, username)
-
-        # Add assistant response to chat history
-        st.session_state.chat_histories[page_hash].append({"role": "assistant", "content": full_response})
-
-if __name__ == "__main__":
-    chat_interface()

app/Frontend/pages/rag_page.py

@@ -1,9 +0,0 @@
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-from pages.page_base import chat_interface
-
-
-chat_title = "RAG Chat App"
-url = "[YOUR RAG CHAT URL]"
-page_hash = get_script_run_ctx().page_script_hash
-
-chat_interface(chat_title, page_hash, url)

app/Frontend/pages/simple_page.py

@@ -1,12 +0,0 @@
-# import streamlit as st
-# import time
-# from langserve import RemoteRunnable
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-import streamlit as st
-from pages.page_base import chat_interface
-
-chat_title = "Simple Chat App"
-url = "https://damienbenveniste-backend.hf.space/simple"
-page_hash = get_script_run_ctx().page_script_hash
-
-chat_interface(chat_title, page_hash, url)

app/Frontend/requirements.txt

@@ -1 +0,0 @@
-langserve[client]

app/Backend/app/callbacks.py → callbacks.py

@@ -15,7 +15,19 @@ class LogResponseCallback(BaseCallbackHandler):
         """Run when llm ends running."""
         # TODO: The function on_llm_end is going to be called when the LLM stops sending 
         # the response. Use the crud.add_message function to capture that response.
-        raise NotImplemented
+        type = 'AI'
+        user_data = crud.get_or_create(db, self.user_request.username) 
+        user_id = user_data.user_id
+        timestamp  = datetime.now()
+        message = outputs.generations[0][0].text # answer from the prompt message
+        message_to_add = schemas.MessageBase(
+        user_id = user_id,
+        message = message,
+        type = type,
+        timestamp = timestamp
+    )
+        _ =  crud.add_message(self.db, message_to_add, self.user_request.username )
+        # raise NotImplemented
 
     def on_llm_start(
         self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any

app/Backend/app/chains.py → chains.py

@@ -1,50 +1,66 @@
 import os
 from langchain_huggingface import HuggingFaceEndpoint
 from langchain_core.runnables import RunnablePassthrough
+
 import schemas
+import prompts
 from prompts import (
     raw_prompt,
     raw_prompt_formatted,
     format_context,
-    tokenizer
+    history_prompt_formatted,
+    standalone_prompt_formatted,
+    rag_prompt_formatted
 )
 from data_indexing import DataIndexer
+from transformers import AutoTokenizer
 
 data_indexer = DataIndexer()
 
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
+
 llm = HuggingFaceEndpoint(
     repo_id="meta-llama/Meta-Llama-3-8B-Instruct",
+
     huggingfacehub_api_token=os.environ['HF_TOKEN'],
     max_new_tokens=512,
     stop_sequences=[tokenizer.eos_token],
     streaming=True,
+    # task="conversational", 
+    task="text-generation",   
 )
 
 simple_chain = (raw_prompt | llm).with_types(input_type=schemas.UserQuestion)
 
 # TODO: create formatted_chain by piping raw_prompt_formatted and the LLM endpoint.
-formatted_chain = (raw_prompt_formatted | llm).with_types(input_types=schemas.UserQuestion)
+formatted_chain = (raw_prompt_formatted | llm).with_types(input_type=schemas.UserQuestion)
 
 # TODO: use history_prompt_formatted and HistoryInput to create the history_chain
-history_chain = None
+history_chain = (history_prompt_formatted | llm).with_types(input_type=schemas.HistoryInput)
 
 # TODO: Let's construct the standalone_chain by piping standalone_prompt_formatted with the LLM
-standalone_chain = None
+standalone_chain = (standalone_prompt_formatted | llm).with_types(input_type=schemas.HistoryInput)
 
 input_1 = RunnablePassthrough.assign(new_question=standalone_chain)
 input_2 = {
     'context': lambda x: format_context(data_indexer.search(x['new_question'])),
-    'standalone_question': lambda x: x['new_question']
+    'standalone_question': lambda x: x['new_question'] # new question was the parameter in input1
 }
 input_to_rag_chain = input_1 | input_2
 
 # TODO: use input_to_rag_chain, rag_prompt_formatted, 
 # HistoryInput and the LLM to build the rag_chain.
-rag_chain = None
+rag_chain = (input_to_rag_chain | rag_prompt_formatted | llm).with_types(input_type=schemas.RagInput)
 
 # TODO:  Implement the filtered_rag_chain. It should be the 
 # same as the rag_chain but with hybrid_search = True.
-filtered_rag_chain = None
+
+input_2_hybrid_search = {
+    'context': lambda x: format_context(data_indexer.search(x['new_question'], hybrid_search=True)),
+    'standalone_question': lambda x: x['new_question']
+}
+
+filtered_rag_chain = (input_1 | input_2_hybrid_search | rag_prompt_formatted | llm ).with_types(input_type=schemas.RagInput)
 
 
 

app/Backend/app/crud.py → crud.py

@@ -17,7 +17,28 @@ def add_message(db: Session, message: schemas.MessageBase, username: str):
     # - create a models.Message instance
     # - pass the retrieved user to the message instance
     # - save the message instance to the database
-    raise NotImplemented
+    user_data = get_or_create_user(db, username)
+    db_message = models.Message(
+        message=message.message,
+        type=message.type,
+        timestamp=message.timestamp,
+        user_id=user_data.id
+    )
+    db.add(db_message)
+    db.commit()
+    db.refresh(db_message)
+    # raise NotImplemented
+    return message 
 
 def get_user_chat_history(db: Session, username: str):
-    raise NotImplemented
+    # chat_history = db.
+    user_data = get_or_create_user(db, username)
+    messages = db.query(models.Message.message,
+    models.Message.type,
+    models.Message.timestamp
+    ).filter(models.Message.user_id==user_data.id).all()
+
+    if not messages:
+        return []
+    return messages
+    # raise NotImplemented

app/Backend/app/data_indexing.py → data_indexing.py

@@ -5,6 +5,7 @@ from pinecone.grpc import PineconeGRPC as Pinecone
 from pinecone import ServerlessSpec
 from langchain_community.vectorstores import Chroma
 from langchain_openai import OpenAIEmbeddings
+from huggingface_hub import InferenceClient
 
 current_dir = Path(__file__).resolve().parent
 
@@ -16,22 +17,31 @@ class DataIndexer:
     def __init__(self, index_name='langchain-repo') -> None:
 
         # TODO: choose your embedding model
-        # self.embedding_client = InferenceClient(
-        #     "dunzhang/stella_en_1.5B_v5",
-        #      token=os.environ['HF_TOKEN'],
-        # )
-        self.embedding_client = OpenAIEmbeddings()
+        self.embedding_client = InferenceClient(
+            "dunzhang/stella_en_1.5B_v5",
+             token=os.environ['HF_TOKEN'],
+        )
+        self.spec = ServerlessSpec(
+            cloud = 'aws',
+            region='us-east-1'
+        )
+        # self.embedding_client = OpenAIEmbeddings()
         self.index_name = index_name
         self.pinecone_client = Pinecone(api_key=os.environ.get('PINECONE_API_KEY'))
 
         if index_name not in self.pinecone_client.list_indexes().names():
             # TODO: create your index if it doesn't exist. Use the create_index function. 
             # Make sure to choose the dimension that corresponds to your embedding model
-            pass
-
+            self.pinecone_client.create_index(
+                name=index_name,
+                dimension=1024,
+                metric='cosine',
+                spec=self.spec
+            )
+            
         self.index = self.pinecone_client.Index(self.index_name)
         # TODO: make sure to build the index.
-        self.source_index = None
+        self.source_index = self.get_source_index()
 
     def get_source_index(self):
         if not os.path.isfile(self.source_file):
@@ -60,21 +70,23 @@ class DataIndexer:
 
             # TODO: create a list of the vector representations of each text data in the batch
             # TODO: choose your embedding model
-            # values = self.embedding_client.embed_documents([
-            #     doc.page_content for doc in batch
-            # ])
+            values = self.embedding_client.embed_documents([
+                doc.page_content for doc in batch
+            ])
 
             # values = self.embedding_client.feature_extraction([
             #     doc.page_content for doc in batch
             # ])
-            values = None
+            # values = None
 
             # TODO: create a list of unique identifiers for each element in the batch with the uuid package.
-            vector_ids = None
+            vector_ids = [uuid.uuid4() for _ in batch]
 
             # TODO: create a list of dictionaries representing the metadata. Capture the text data 
             # with the "text" key, and make sure to capture the rest of the doc.metadata.
-            metadatas = None
+            metadatas = [{"text": doc.page_content,
+                **doc.metadata
+            } for doc in batch]
 
             # create a list of dictionaries with keys "id" (the unique identifiers), "values"
             # (the vector representation), and "metadata" (the metadata).
@@ -86,8 +98,8 @@ class DataIndexer:
 
             try: 
                 # TODO: Use the function upsert to upload the data to the database.
-                upsert_response = None
-                print(upsert_response)
+                upsert_response = self.index.upsert(vectors)
+                print(f"successfully indexed batch {upsert_response}")
             except Exception as e:
                 print(e)
 
@@ -103,17 +115,22 @@ class DataIndexer:
         # TODO: embed the text_query by using the embedding model
         # TODO: choose your embedding model
         # vector = self.embedding_client.feature_extraction(text_query)
-        # vector = self.embedding_client.embed_query(text_query)
-        vector = None
+        vector = self.embedding_client.embed_query(text_query)
+        # vector = None
 
          # TODO: use the vector representation of the text_query to 
          # search the database by using the query function.
-        result = None
+        result = self.index.query(vector,
+        filter=filter,
+        top_k=top_k,
+        include_values=True
+        )
 
         docs = []
         for res in result["matches"]:
             # TODO: From the result's metadata, extract the "text" element.
-            pass
+            docs.append(res['metadata']['text'])
+            # pass
 
         return docs
     

app/Backend/app/main.py → main.py

@@ -5,13 +5,24 @@ from sse_starlette.sse import EventSourceResponse
 from langserve.serialization import WellKnownLCSerializer
 from typing import List
 from sqlalchemy.orm import Session
+from datetime import datetime
 
 import schemas
-from chains import simple_chain, formatted_chain
+from models import Message
+from chains import simple_chain, formatted_chain, history_chain, rag_chain
+from prompts import format_chat_history
 import crud, models, schemas
 from database import SessionLocal, engine
 from callbacks import LogResponseCallback
 
+# temporary
+from database import engine
+import models
+
+# drop all tables and recreate
+models.Base.metadata.drop_all(bind=engine)
+models.Base.metadata.create_all(bind=engine)
+
 
 models.Base.metadata.create_all(bind=engine)
 
@@ -42,9 +53,18 @@ async def simple_stream(request: Request):
 @app.post("/formatted/stream")
 async def formatted_stream(request: Request):
     # TODO: use the formatted_chain to implement the "/formatted/stream" endpoint.
-    data = await request.json()
-    user_question = schemas.UserQuestion(**data['input'])
-    return EventSourceResponse(generate_stream(user_question,formatted_chain))
+    try:
+        data = await request.json()
+        user_question = schemas.UserQuestion(**data['input'])   
+        return EventSourceResponse(
+            generate_stream(
+                input_data = user_question, 
+                runnable = formatted_chain )
+                )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
     # raise NotImplemented
 
 
@@ -57,7 +77,34 @@ async def history_stream(request: Request, db: Session = Depends(get_db)):
     # - We add as part of the user history the current question by using add_message.
     # - We create an instance of HistoryInput by using format_chat_history.
     # - We use the history input within the history chain.
-    raise NotImplemented
+    data = await request.json()
+    user_request = schemas.UserRequest(**data['input'])
+    # user_data = await crud.get_or_create(db, user_request.username) 
+    # since history stream means 
+    # we have existing user's no need to check for a user
+    chat_history = crud.get_user_chat_history(db, user_request.username)
+    history_input = schemas.HistoryInput(
+        chat_history = format_chat_history(chat_history),
+        question=user_request.question
+    )
+
+    ## adding messgae to message database
+    type = 'Human'
+    user_data = crud.get_or_create_user(db, user_request.username) 
+    user_id = user_data.id
+    timestamp  = str(datetime.now())
+    add_message = schemas.MessageBase(
+        user_id = user_id,
+        message = user_request.question,
+        type = type,
+        timestamp = timestamp,
+        user=user_request.username,
+    )
+
+    _ = crud.add_message(db,add_message, username = user_request.username)
+    # chat history contains: [{ message, type, timestamp}]
+    return EventSourceResponse(generate_stream(history_input, history_chain))
+    # raise NotImplemented
 
 
 @app.post("/rag/stream")
@@ -69,7 +116,27 @@ async def rag_stream(request: Request, db: Session = Depends(get_db)):
     # - We add as part of the user history the current question by using add_message.
     # - We create an instance of HistoryInput by using format_chat_history.
     # - We use the history input within the rag chain.
-    raise NotImplemented
+    data = await request.json()
+    user_request = schemas.UserRequest(**data['input'])
+    messages = crud.get_user_chat_history(db, user_request.username)
+    chat_history = format_chat_history(messages)
+    
+    history_input = schemas.HistoryInput( chat_history = format_chat_history(chat_history), question=user_request.question)
+    ## adding messgae to message database
+    type = 'Human'
+    user_data = crud.get_or_create_user(db, user_request.username) 
+    user_id = user_data.id
+    timestamp  = str(datetime.now())
+    add_message = schemas.MessageBase(
+        user_id = user_id,
+        message = user_request.question,
+        type = type,
+        timestamp = timestamp
+    )
+
+    _ = crud.add_message(db,add_message, username = user_request.username)
+    return EventSourceResponse(generate_stream(history_input, rag_chain))
+    # raise NotImplemented
 
 
 @app.post("/filtered_rag/stream")
@@ -81,7 +148,36 @@ async def filtered_rag_stream(request: Request, db: Session = Depends(get_db)):
     # - We add as part of the user history the current question by using add_message.
     # - We create an instance of HistoryInput by using format_chat_history.
     # - We use the history input within the filtered rag chain.
-    raise NotImplemented
+    data = await request.json()
+    user_request = models.UserRequest(data)
+    
+    messages = db.Query(
+        Message.message,
+        Message.type,
+        Message.timestamp
+    ).filter(Message.user_id == user_request.username)
+    chat_history = format_chat_history(messages)
+    
+    history_input = schemas.HistoryInput(
+        chat_history = format_chat_history(chat_history),
+        question=user_request.question
+    )
+    ## adding messgae to message database
+    type = 'Human'
+    user_data = crud.get_or_create_user(db, user_request.username) 
+    user_id = user_data.id
+    timestamp  = str(datetime.now())
+    add_message = schemas.MessageBase(
+        user_id = user_id,
+        message = user_request.question,
+        type = type,
+        timestamp = timestamp
+    )
+
+    _ = crud.add_message(db,add_message, username = user_request.username)
+
+    return EventSourceResponse(generate_stream(history_input, filtered_rag_chain))
+    # raise NotImplemented
     
 
 

app/Backend/app/models.py → models.py

@@ -3,6 +3,7 @@ from sqlalchemy.orm import relationship
 
 from database import Base
 
+
 class User(Base):
     __tablename__ = "users"
 
@@ -18,4 +19,11 @@ class User(Base):
 # attribute as a foreign key.
 class Message(Base):
     __tablename__ = "messages"
-    pass
+
+    id = Column(Integer, primary_key=True, index=True)
+    message = Column(String)
+    type = Column(String)
+    timestamp = Column(DateTime)
+    user_id = Column(Integer, ForeignKey('users.id'))
+    user = relationship("User",back_populates="messages")
+    

app/Backend/app/prompts.py → prompts.py

@@ -6,15 +6,15 @@ import models
 def format_prompt(prompt) -> PromptTemplate:
     # TODO: format the input prompt by using the model specific instruction template
     template = f"""
-    <|begin_of_text|><|start_header_id|>system<end_header_id>
+    <|begin_of_text|><|start_header_id|>system<|end_header_id|>
     You are a helpful assistant.<|eot_id|>
     <|start_header_id|>user<|end_header_id|>
     {prompt}<|eot_id|>
     <|start_header_id|>assistant<|end_header_id|>
-
     """
+
     prompt_template = PromptTemplate(
-        input_variables=["question"],
+        # input_variables=["question"], the variables will be auto detected by langchain package
         template = template
     )
     # TODO: return a langchain PromptTemplate
@@ -24,39 +24,73 @@ def format_prompt(prompt) -> PromptTemplate:
 def format_chat_history(messages: List[models.Message]):
     # TODO:  implement format_chat_history to format 
     # the list of Message into a text of chat history.
-    raise NotImplemented
+    chat_history = ""
+    for msg in messages:
+        chat_history += msg['message']
+        chat_history += "\n---\n"
+    # combined all messages from the list for sending it to the model prompt.
+    return chat_history
+    # raise NotImplemented
 
 def format_context(docs: List[str]):
     # TODO:  the output of the DataIndexer.search is a list of text, 
     # so we need to concatenate that list into a text that can fit into 
     # the rag_prompt_formatted. Implement format_context that takes a 
     # like of strings and returns the context as one string.
-    raise NotImplemented
+    if not docs:
+        return ""
+    combined_text = ""
+    combined_text = "\n\n---\n\n".join(
+        doc.strip() for doc in docs if doc.strip()   
+    )
+    # raise NotImplemented
+    return combined_text
 
 raw_prompt = "{question}"
 
 # TODO: Create the history_prompt prompt that will capture the question and the conversation history. 
 # The history_prompt needs a {chat_history} placeholder and a {question} placeholder.
-history_prompt: str = None
+history_prompt: str = """
+Given the following conversation provide a helpful answer to the following up question.
+
+Chat History:
+
+{chat_history}
+
+Follow Up Question: {question}
+
+helpful answer:
+"""
 
 # TODO: Create the standalone_prompt prompt that will capture the question and the chat history
 # to generate a standalone question. It needs a {chat_history} placeholder and a {question} placeholder,
-standalone_prompt: str = None
+standalone_prompt: str = """
+Given the following conversation and a follow up question, rephrase the 
+follow up question to be a standalone question, in its original language.
+Chat History:
+{chat_history}
+Follow Up Input: {question}
+Standalone question:
+"""
 
 # TODO: Create the rag_prompt that will capture the context and the standalone question to generate
 # a final answer to the question.
-rag_prompt: str = None
+rag_prompt: str = """
+Answer the question based only on the following context:
+{context}
+Question: {standalone_question}
+"""
 
 # TODO: create raw_prompt_formatted by using format_prompt
 raw_prompt_formatted = format_prompt(raw_prompt)
 raw_prompt = PromptTemplate.from_template(raw_prompt)
 
 # TODO: use format_prompt to create history_prompt_formatted
-history_prompt_formatted: PromptTemplate = None
+history_prompt_formatted: PromptTemplate = format_prompt(history_prompt)
 # TODO: use format_prompt to create standalone_prompt_formatted
-standalone_prompt_formatted: PromptTemplate = None
+standalone_prompt_formatted: PromptTemplate = format_prompt(standalone_prompt)
 # TODO: use format_prompt to create rag_prompt_formatted
-rag_prompt_formatted: PromptTemplate = None
+rag_prompt_formatted: PromptTemplate = format_prompt(rag_prompt)
 
 
 

requirements.txt

@@ -1,2 +1,109 @@
-fastapi
-uvicorn[standard]
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.10.0
+appier==1.34.6
+async-timeout==4.0.3
+attrs==25.3.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.8.3
+charset-normalizer==3.4.2
+click==8.2.1
+dataclasses-json==0.6.7
+distro==1.9.0
+exceptiongroup==1.3.0
+fastapi==0.116.1
+filelock==3.18.0
+frozenlist==1.7.0
+fsspec==2025.7.0
+gitdb==4.0.12
+GitPython==3.1.45
+google-api==0.1.12
+google-api-core==2.25.1
+google-auth==2.40.3
+google-cloud-core==2.4.3
+googleapis-common-protos==1.70.0
+grpcio==1.74.0
+grpcio-tools==1.74.0
+h11==0.16.0
+hf-xet==1.1.5
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.34.3
+idna==3.10
+Jinja2==3.1.6
+jiter==0.10.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.0
+jsonschema-specifications==2025.4.1
+langchain==0.3.27
+langchain-community==0.3.27
+langchain-core==0.3.72
+langchain-huggingface==0.3.1
+langchain-openai==0.3.28
+langchain-text-splitters==0.3.9
+langserve==0.3.1
+langsmith==0.4.11
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+multidict==6.6.3
+mypy_extensions==1.1.0
+narwhals==2.0.1
+numpy==2.2.6
+openai==1.98.0
+orjson==3.11.1
+packaging==24.2
+pandas==2.3.1
+pathlib==1.0.1
+pillow==11.3.0
+pinecone==7.3.0
+pinecone-plugin-assistant==1.7.0
+pinecone-plugin-interface==0.0.7
+propcache==0.3.2
+proto-plus==1.26.1
+protobuf==6.31.1
+pyarrow==21.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pydantic==2.11.7
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+pydeck==0.9.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.4
+requests-toolbelt==1.0.0
+rpds-py==0.26.0
+rsa==4.9.1
+safetensors==0.5.3
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+SQLAlchemy==2.0.42
+sse-starlette==3.0.2
+starlette==0.47.2
+streamlit==1.47.1
+tenacity==9.1.2
+tiktoken==0.9.0
+tokenizers==0.21.4
+toml==0.10.2
+tornado==6.5.1
+tqdm==4.67.1
+transformers==4.54.1
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+yarl==1.20.1
+zstandard==0.23.0

app/Backend/app/schemas.py → schemas.py

@@ -1,4 +1,5 @@
 from pydantic.v1 import BaseModel
+from datetime import datetime
 
 
 class UserQuestion(BaseModel):
@@ -6,14 +7,27 @@ class UserQuestion(BaseModel):
 
 # TODO: create a HistoryInput data model with a chat_history and question attributes.
 class HistoryInput(BaseModel):
-    pass
+    question: str
+    chat_history: str
 
 # TODO: let's create a UserRequest data model with a question and username attribute. 
 # This will be used to parse the input request.
 class UserRequest(BaseModel):
     username: str
+    question: str
+
 
 # TODO: implement MessageBase as a schema mapping from the database model to the 
 # FastAPI data model. Basically MessageBase should have the same attributes as models.Message
 class MessageBase(BaseModel):
-    pass
+    # id: int
+    message: str
+    timestamp: datetime
+    type: str
+    user_id: int
+    user: str
+
+# created additional 
+class RagInput(BaseModel):
+    standalone_question: str
+    context: str