feat: make it factory design pattern

fraudTrainData.pkl

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

requirements.txt

@@ -3,4 +3,6 @@ pandas
 streamlit
 matplotlib
 pandas
-tabulate
+tabulate
+huggingface_hub
+langchain_community

src/FinancialAgentApp.py

@@ -0,0 +1,192 @@
+from abc import ABC, abstractmethod
+import pickle
+from models import ResponseState
+from prompt import REFINERY_PROMPT, FINAL_PROMPT
+from langchain_community.vectorstores import FAISS
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+from openai import OpenAI
+import pickle
+import io
+
+class FinancialAgentApp (ABC):
+    def __init__(self, st, model_name):
+        self.st = st
+        self.df = pickle.load(open("fraudTrainData.pkl", "rb"))
+        
+        self.model_name = model_name
+
+        if "messages" not in self.st.session_state:
+            self.st.session_state.messages = []
+
+    def render_header(self):
+        self.st.title("Financial Agent")
+
+    def render_messages(self):
+        """Render previous chat messages."""
+        for message in self.st.session_state.messages:
+            with self.st.chat_message(message["role"]):
+                self.st.markdown(message["content"])
+
+    @abstractmethod
+    def __stream_answer__(self, instructions, input_messages):
+        """Stream OpenAI response as a generator."""
+        pass
+
+    def process_prompt(self, prompt):
+        """Main pipeline for processing a new user input."""
+        self.st.session_state.messages.append({"role": "user", "content": prompt})
+        with self.st.chat_message("user"):
+            self.st.markdown(prompt)
+
+        # Step 1: Run refinery prompt
+        response = self.client.responses.parse(
+            model=self.model_name,
+            instructions=REFINERY_PROMPT.format(
+                df_head=self.df.head().to_markdown(),
+                df_columns=self.df.columns.tolist(),
+                df_sample=self.df.sample(5).to_markdown()
+            ),
+            input=[{"role": m["role"], "content": m["content"]} for m in self.st.session_state.messages],
+            stream=False,
+            text_format=ResponseState
+        )
+
+        response_state: ResponseState = response.output_parsed
+
+        # Step 2: Check if context is needed
+        if response_state.isNeedContext:
+            context_prompt = self.handle_context(response_state)
+            self.generate_final_answer(context_prompt)
+        else:
+            self.display_final_answer(response_state.response)
+
+    def __safe_savefig__(*args, **kwargs):
+        buf = io.BytesIO()
+        plt.savefig(buf, format="png")
+        buf.seek(0)
+        return buf
+    
+    @abstractmethod
+    def handle_context(self, response_state: ResponseState) -> str:
+        """Handle context if need to add context from data/pdf"""
+        pass
+
+    def generate_final_answer(self, context_prompt: str):
+        """Generate and stream the final answer with context."""
+        with self.st.chat_message("assistant"):
+            answer = self.st.write_stream(
+                self.stream_answer(
+                    instructions=FINAL_PROMPT,
+                    input_messages=[
+                        {"role": m["role"], "content": m["content"]}
+                        for m in self.st.session_state.messages
+                    ] + [{"role": "user", "content": context_prompt}]
+                )
+            )
+        self.st.session_state.messages.append({"role": "assistant", "content": answer})
+
+    def display_final_answer(self, answer: str):
+        """Display a non-streamed assistant answer."""
+        self.st.session_state.messages.append({"role": "assistant", "content": answer})
+        with self.st.chat_message("assistant"):
+            self.st.markdown(answer)
+
+    def run(self):
+        """Run the app."""
+        self.render_header()
+        self.render_messages()
+
+        if prompt := self.st.chat_input("What is up?"):
+            self.process_prompt(prompt)
+
+
+
+class HFFinancialRAG(FinancialAgentApp):
+    def __init__(self, st, base_url, api_key, model_name = 'Qwen/Qwen3-4B', vector_id="vs_68bf713eea2c81919ac08298a05d6704", embedding=None):
+        if not base_url:
+            raise ValueError("base_url cannot be None or empty.")
+        if not api_key:
+            raise ValueError("api_key cannot be None or empty.")
+        super().__init__(st, model_name)
+        self.client = OpenAI(base_url=base_url, api_key=api_key)
+        self.vector_db = FAISS.load_local(vector_id, embedding, allow_dangerous_deserialization=True)
+
+
+    def __handle_context__(self, response_state: ResponseState) -> str:
+        """Handle additional context (data, PDF, etc.)."""
+        context_prompt = ""
+        if response_state.contextType in ("data", "both"):
+            local_scope = {"df": self.df, "np": np, "pd": pd, "plt": plt, "savefig": self.__safe_savefig__}
+            exec(response_state.code, {}, local_scope)
+
+            fig = plt.gcf()
+            if fig.get_axes():  # if a chart was generated
+                with self.st.chat_message("assistant"):
+                    self.st.pyplot(fig)
+                plt.close(fig)
+
+            context_prompt = "## CONTEXT DATAFRAME.\n"
+            context_prompt += str(local_scope.get("result", ""))
+
+        if response_state.contextType in ("pdf", "both"):
+            context_prompt += "## CONTEXT PDF.\n"
+            results = self.vector_db.similarity_search(response_state.retriverKey, k=5)
+            for i, doc in enumerate(results, 1):
+                context_prompt += f"### Document {i}\n{doc.page_content}\n"
+        return context_prompt
+    
+    def __stream_answer__(self, instructions, input_messages):
+        response_stream = self.client.responses.create(
+            model=self.model_name,
+            instructions=instructions,
+            input=input_messages,
+            stream=True
+        )
+        for chunk in response_stream:
+            if chunk.type == 'response.output_text.delta':
+                yield chunk.delta
+
+
+class OpenAIFinancialRAG(FinancialAgentApp):
+    def __init__(self, st, model_name = "gpt-5-mini-2025-08-07"):
+        super().__init__(st, model_name)
+        self.clien = OpenAI()
+
+    def __stream_answer__(self, instructions, input_messages):
+        response_stream = self.client.responses.create(
+            model=self.model_name,
+            instructions=instructions,
+            input=input_messages,
+            stream=True,
+            tools=[{
+                "type": "file_search",
+                "vector_store_ids": ['vs_68bf713eea2c81919ac08298a05d6704']
+            }]
+        )
+        for chunk in response_stream:
+            if chunk.type == 'response.output_text.delta':
+                yield chunk.delta
+
+def __handle_context__(self, response_state: ResponseState):
+        """Handle additional context (data, PDF, etc.)."""
+        context_prompt = ""
+        if response_state.contextType in ("data", "both"):
+            local_scope = {"df": self.df, "np": np, "pd": pd, "plt": plt, "savefig": self.__safe_savefig__}
+            exec(response_state.code, {}, local_scope)
+
+            fig = plt.gcf()
+            if fig.get_axes():  # if a chart was generated
+                with self.st.chat_message("assistant"):
+                    self.st.pyplot(fig)
+                plt.close(fig)
+
+            context_prompt = "## CONTEXT DATAFRAME.\n"
+            context_prompt += str(local_scope.get("result", ""))
+
+        # Placeholder for PDF or other context handling
+        # elif response_state.contextType in ("pdf", "both"):
+        #     context_prompt = "Provide the relevant information from the PDF documents."
+
+        return context_prompt

src/streamlit_app.py

@@ -1,131 +1,14 @@
-from models import ResponseState
-from prompt import REFINERY_PROMPT, FINAL_PROMPT
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-import streamlit as st
-from openai import OpenAI
-import pickle
-import io
+from huggingface_hub import hf_hub_download
+from FinancialAgentApp import HFFinancialRAG, OpenAIFinancialRAG
+import os
 
-class FinancialAgentApp:
-    def __init__(self):
-        self.client = OpenAI()
-        self.df = pickle.load(open("fraudTrainData.pkl", "rb"))
-        self.model_name = "gpt-5-mini-2025-08-07"
-
-        if "messages" not in st.session_state:
-            st.session_state.messages = []
-        st.session_state["openai_model"] = self.model_name
-
-    def render_header(self):
-        st.title("Financial Agent")
-
-    def render_messages(self):
-        """Render previous chat messages."""
-        for message in st.session_state.messages:
-            with st.chat_message(message["role"]):
-                st.markdown(message["content"])
-
-    def stream_answer(self, instructions, input_messages):
-        """Stream OpenAI response as a generator."""
-        response_stream = self.client.responses.create(
-            model=self.model_name,
-            instructions=instructions,
-            input=input_messages,
-            stream=True,
-            tools=[{
-                "type": "file_search",
-                "vector_store_ids": ['vs_68bf713eea2c81919ac08298a05d6704']
-            }]
-        )
-        for chunk in response_stream:
-            if chunk.type == 'response.output_text.delta':
-                yield chunk.delta
-
-    def process_prompt(self, prompt):
-        """Main pipeline for processing a new user input."""
-        st.session_state.messages.append({"role": "user", "content": prompt})
-        with st.chat_message("user"):
-            st.markdown(prompt)
-
-        # Step 1: Run refinery prompt
-        response = self.client.responses.parse(
-            model=self.model_name,
-            instructions=REFINERY_PROMPT.format(
-                df_head=self.df.head().to_markdown(),
-                df_columns=self.df.columns.tolist(),
-                df_sample=self.df.sample(5).to_markdown()
-            ),
-            input=[{"role": m["role"], "content": m["content"]} for m in st.session_state.messages],
-            stream=False,
-            text_format=ResponseState
-        )
-
-        response_state: ResponseState = response.output_parsed
-
-        # Step 2: Check if context is needed
-        if response_state.isNeedContext:
-            context_prompt = self.handle_context(response_state)
-            self.generate_final_answer(context_prompt)
-        else:
-            self.display_final_answer(response_state.response)
-    def __safe_savefig__(*args, **kwargs):
-        buf = io.BytesIO()
-        plt.savefig(buf, format="png")
-        buf.seek(0)
-        return buf
-    
-    def handle_context(self, response_state: ResponseState) -> str:
-        """Handle additional context (data, PDF, etc.)."""
-        context_prompt = ""
-        if response_state.contextType in ("data", "both"):
-            local_scope = {"df": self.df, "np": np, "pd": pd, "plt": plt, "savefig": self.__safe_savefig__}
-            exec(response_state.code, {}, local_scope)
-
-            fig = plt.gcf()
-            if fig.get_axes():  # if a chart was generated
-                with st.chat_message("assistant"):
-                    st.pyplot(fig)
-                plt.close(fig)
-
-            context_prompt = "## CONTEXT DATAFRAME.\n"
-            context_prompt += str(local_scope.get("result", ""))
-
-        # Placeholder for PDF or other context handling
-        # elif response_state.contextType in ("pdf", "both"):
-        #     context_prompt = "Provide the relevant information from the PDF documents."
-
-        return context_prompt
-
-    def generate_final_answer(self, context_prompt: str):
-        """Generate and stream the final answer with context."""
-        with st.chat_message("assistant"):
-            answer = st.write_stream(
-                self.stream_answer(
-                    instructions=FINAL_PROMPT,
-                    input_messages=[
-                        {"role": m["role"], "content": m["content"]}
-                        for m in st.session_state.messages
-                    ] + [{"role": "user", "content": context_prompt}]
-                )
-            )
-        st.session_state.messages.append({"role": "assistant", "content": answer})
-
-    def display_final_answer(self, answer: str):
-        """Display a non-streamed assistant answer."""
-        st.session_state.messages.append({"role": "assistant", "content": answer})
-        with st.chat_message("assistant"):
-            st.markdown(answer)
-
-    def run(self):
-        """Run the app."""
-        self.render_header()
-        self.render_messages()
-
-        if prompt := st.chat_input("What is up?"):
-            self.process_prompt(prompt)
 
 if __name__ == "__main__":
-    app = FinancialAgentApp()
+    index_path = hf_hub_download(
+    repo_id="mrfirdauss/FaissBhatlaBook",  
+    filename="vs_68bf713eea2c81919ac08298a05d6704/index.faiss",
+    repo_type="dataset"
+    )
+    app = OpenAIFinancialRAG()
+
     app.run()

vs_68bf713eea2c81919ac08298a05d6704/index.pkl

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