modified rag system

.gitignore

@@ -1,3 +1,15 @@
 env.sh
 
-test_request.py
+test_request.py
+
+.DS_Store
+
+__pycache__
+
+sources.txt
+
+.venv
+
+data_indexing.ipynb
+
+app/code_data/

app/callbacks.py

@@ -15,8 +15,8 @@ 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.
-        print(outputs)
-        print(outputs.generations[0][0].text)
+        # print(outputs)
+        # print(outputs.generations[0][0].text)
         crud.add_message(self.db, schemas.MessageBase(message=outputs.generations[0][0].text, type="assistant"), self.user_request.username)
 
     def on_llm_start(

app/chains.py

@@ -6,7 +6,9 @@ from app.prompts import (
     raw_prompt,
     raw_prompt_formatted,
     history_prompt_formatted,
+    standalone_prompt_formatted,
     format_context,
+    rag_prompt_formatted,
     tokenizer
 )
 from app.data_indexing import DataIndexer
@@ -30,22 +32,29 @@ formatted_chain = (raw_prompt_formatted | llm).with_types(input_type=schemas.Use
 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']
-# }
-# input_to_rag_chain = input_1 | input_2
+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']
+}
+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.HistoryInput)
 
 # 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_1 = RunnablePassthrough.assign(new_question=standalone_chain)
+input_2 = {
+    'context': lambda x: format_context(data_indexer.search(x['new_question'], hybrid_search=True)),
+    'standalone_question': lambda x: x['new_question']
+}
+filtered_input_to_rag_chain = input_1 | input_2
+filtered_rag_chain = (filtered_input_to_rag_chain | rag_prompt_formatted | llm).with_types(input_type=schemas.HistoryInput)
 
 
 

app/code_data/langchain_repo

@@ -0,0 +1 @@
+Subproject commit 82b5b77940e97f65179efa0268031c47d0584a1c

app/data_indexing.py

@@ -38,6 +38,7 @@ class DataIndexer:
             )
 
         self.index = self.pinecone_client.Index(self.index_name)
+        print(self.index.query(namespace=''))
         # TODO: make sure to build the index.
         self.source_index = self.get_source_index()
 
@@ -75,14 +76,19 @@ class DataIndexer:
             # values = self.embedding_client.feature_extraction([
             #     doc.page_content for doc in batch
             # ])
-            values = None
+            values = self.embedding_client.embed_documents([
+                doc.page_content for doc in batch
+            ])
 
             # TODO: create a list of unique identifiers for each element in the batch with the uuid package.
-            vector_ids = None
+            vector_ids = [str(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).
@@ -94,7 +100,7 @@ class DataIndexer:
 
             try: 
                 # TODO: Use the function upsert to upload the data to the database.
-                upsert_response = None
+                upsert_response = self.index.upsert(vectors=vectors)
                 print(upsert_response)
             except Exception as e:
                 print(e)
@@ -111,17 +117,20 @@ 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)
          # 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,
+                                top_k=top_k,
+                                filter=filter, # type: ignore
+                                include_values=True,
+                                include_metadata=True)
 
         docs = []
         for res in result["matches"]:
             # TODO: From the result's metadata, extract the "text" element.
-            pass
+            # print(res.metadata)
+            docs.append(res.metadata['text'])
 
         return docs
     

app/main.py

@@ -6,7 +6,7 @@ from langserve.serialization import WellKnownLCSerializer
 from typing import List
 from sqlalchemy.orm import Session
 
-from app.chains import simple_chain, formatted_chain, history_chain
+from app.chains import simple_chain, formatted_chain, history_chain, rag_chain
 import app.crud as crud
 import app.models as models
 import app.schemas as schemas
@@ -64,7 +64,7 @@ async def history_stream(request: Request, db: Session = Depends(get_db)):
     chat_history_str = format_chat_history(chat_history)
     crud.add_message(db, schemas.MessageBase(message=user_request.question, type="user"), user_name)
     history_input = schemas.HistoryInput(chat_history=chat_history_str, question=user_request.question)
-    print(history_input)
+    # print(history_input)
     return EventSourceResponse(generate_stream(history_input, history_chain, [LogResponseCallback(user_request, db)]))
 
 
@@ -77,7 +77,14 @@ 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'])
+    user_name = user_request.username
+    chat_history = crud.get_user_chat_history(db, user_name)
+    chat_history_str = format_chat_history(chat_history)
+    crud.add_message(db, schemas.MessageBase(message=user_request.question, type="user"), user_name)
+    history_input = schemas.HistoryInput(chat_history=chat_history_str, question=user_request.question)
+    return EventSourceResponse(generate_stream(history_input, rag_chain, [LogResponseCallback(user_request, db)]))
 
 
 @app.post("/filtered_rag/stream")

app/prompts.py

@@ -30,7 +30,10 @@ def format_context(docs: List[str]):
     # 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
+    context = ""
+    for doc in docs:
+        context += f"{doc}\n"
+    return context
 
 raw_prompt = "{question}"
 
@@ -44,11 +47,20 @@ 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 = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
+{context}
+Question: {question}
+Helpful Answer:"""
 
 # TODO: create raw_prompt_formatted by using format_prompt
 raw_prompt_formatted = format_prompt(raw_prompt)