adding functionalities

app.py

@@ -1,10 +1,73 @@
+import sys
 import time
 import gradio as gr
-from dotenv import load_dotenv
-from LlmManager import LlmManager
 
-load_dotenv()
-llm_manager = LlmManager()
+from config import initialize
+
+# Define the available options
+stages = [
+    "Opportunity Identification",
+    "Refinement of Business Concept & Resource Acquisition",
+    "Survival and Growth"
+]
+
+strengths_by_stage = {
+    "Opportunity Identification": ["Curiosity", "Perspective", "Creativity", "Hope"],
+    "Refinement of Business Concept & Resource Acquisition": ["Hope", "Bravery", "Honesty", "Love of Learning", "Social Intelligence", "Kindness"],
+    "Survival and Growth": ["Persistence", "Humor", "Self-Regulation", "Zest", "Leadership", "Teamwork", "Fairness"]
+}
+
+ranks = ["High", "Medium", "Low"]
+
+# Set default values
+default_stage = stages[0]
+default_strengths = strengths_by_stage[default_stage]
+default_strength = default_strengths[0]
+
+# Function to update the Strength dropdown when a stage is selected
+def update_strengths(stage):
+    strengths = strengths_by_stage.get(stage, [])
+    return gr.update(choices=strengths, value=strengths[0] if strengths else None)
+
+# Function to store the selected values and show the chat section
+selected_stage = None
+selected_strength = None
+selected_rank = None
+
+def get_question(rank):
+    if rank=="High":
+        return "How would you like to make use of this strength in setting up your business?"
+    elif rank == "Medium":
+        return "How do you plan to leverage this strength in shaping your business approach? Would you prefer to develop it further, seek support, collaborate with others, or take a different path?"
+    elif rank == "Low":
+        return "How would you like to go about (e.g., ignore, develop by…, ask for support to…, team up with others, reconsider choice to be entrepreneur)?"
+    else:
+        return None
+
+def set_chat_config(stage, strength, rank):
+    global selected_stage, selected_strength, selected_rank
+    selected_stage = stage
+    selected_strength = strength
+    selected_rank = rank
+    chat_title = f"### Chat Configuration: {stage} > {strength} > {rank}"
+
+    return (        
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(value=chat_title),
+    )
+
+def reset_configuration():
+
+    return (        
+        gr.update(visible=True),
+        gr.update(visible=False)
+    )
+
+llm_manager, mongo_db_manager = initialize()
+if llm_manager is None or mongo_db_manager is None:
+    print("Error: Failed to initialize configuration. Exiting application.", flush=True)
+    sys.exit(1)
 
 def reset_textbox():
     """Clears the textbox after sending a message."""
@@ -43,6 +106,18 @@ def slow_echo(message, history):
 
     yield history  # Final yield with full message
 
+def llm_setup(stage, strength, rank, history):
+    questions = mongo_db_manager.get_questions("questions", stage, strength, rank)
+    if not questions:
+        yield [{"role": "assistant", "content": "Error: no questions found for the selected configuration. Please try again."}]
+        return
+
+    question = get_question(rank)
+    llm_manager.reset_messages(stage, strength, rank, question, questions)
+
+    message = "Can you help me with this task?"
+    yield from llm_send_message(message, history)
+
 def llm_send_message(message, history):
     if history is None:
         history = []
@@ -50,6 +125,8 @@ def llm_send_message(message, history):
     # Append user message to history
     history.append({"role": "user", "content": message})
 
+    yield history 
+
     # Placeholder for assistant response
     bot_entry = {"role": "assistant", "content": ""}
     history.append(bot_entry)
@@ -57,45 +134,103 @@ def llm_send_message(message, history):
     # Send message to LLM and stream response
     response = ""
     for chunk in llm_manager.send_message(message):  # Streaming response
-        time.sleep(0.05)  # Simulate gradual output
+        time.sleep(0.01)  # Simulate gradual output
         response += chunk
         bot_entry["content"] = response  # Update assistant response progressively
         yield history  # Yield updated history
 
     yield history  # Final yield
 
-
 with gr.Blocks(fill_height=True) as demo:
-    chat = gr.Chatbot(
-        label="My strengths as an entrepreneur",
-        type="messages"
-    ) 
-
-    input = gr.Textbox(
-        label="Input", 
-        placeholder="Type something here..."
-    )
-    input.submit(
-        #fn=slow_echo, 
-        fn=llm_send_message,
-        inputs=[input, chat], 
-        outputs=chat
+    
+    with gr.Column(visible=True) as setup_section:
+        gr.Markdown("### Select your Stage, Strength, and Rank before chatting")
+
+        # Dropdowns for selection
+        stage_dropdown = gr.Dropdown(
+            label="Stage",
+            choices=stages,
+            value=default_stage,
+            interactive=True
+        )
+
+        strength_dropdown = gr.Dropdown(
+            label="Strength",
+            choices=default_strengths,
+            value=default_strength,
+            interactive=True
+        )
+
+        rank_dropdown = gr.Dropdown(
+            label="Rank",
+            choices=ranks,
+            value="High",
+            interactive=True
+        )
+
+        # Update strengths when stage is changed
+        stage_dropdown.change(
+            fn=update_strengths,
+            inputs=[stage_dropdown],
+            outputs=[strength_dropdown]
+        )
+
+        # Button to set chat configuration
+        setup_button = gr.Button("Set Chat Configuration")
+
+    with gr.Column(visible=False) as chat_section:
+
+        chat_configuration = gr.Markdown("")
+
+        reset_button = gr.Button("Reset Chat Configuration")
+    
+        chat = gr.Chatbot(
+            label="My strengths as an entrepreneur",
+            type="messages"
+        ) 
+
+        input = gr.Textbox(
+            label="Input", 
+            placeholder="Type something here..."
+        )
+
+        # Add a hidden state variable to temporarily store the input
+        stored_message = gr.State()
+
+        input.submit(
+            fn=lambda text: (text, ""),  # ✅ Store input in state, clear textbox immediately
+            inputs=[input],  
+            outputs=[stored_message, input]  # ✅ Store value & reset input
+        ).then(
+            fn=llm_send_message,  
+            inputs=[stored_message, chat],  # ✅ Use stored message
+            outputs=chat
+        )
+
+        send_btn.click(
+            fn=lambda text: (text, ""),  
+            inputs=[input],  
+            outputs=[stored_message, input]  
+        ).then(
+            fn=llm_send_message,  
+            inputs=[stored_message, chat],  
+            outputs=chat
+        )
+
+    setup_button.click(
+        fn=set_chat_config,
+        inputs=[stage_dropdown, strength_dropdown, rank_dropdown],
+        outputs=[setup_section, chat_section, chat_configuration]
     ).then(
-        fn=reset_textbox,
-        inputs=None,
-        outputs=input
+        fn=llm_setup,
+        inputs=[stage_dropdown, strength_dropdown, rank_dropdown, chat],
+        outputs=chat
     )
 
-    send_bth = gr.Button("Send")    
-    send_bth.click(
-        #fn=slow_echo, 
-        fn=llm_send_message,
-        inputs=[input, chat], 
-        outputs=chat
-    ).then(
-        fn=reset_textbox,
-        inputs=None,
-        outputs=input
+    reset_button.click(
+        fn=reset_configuration,
+        inputs=None, 
+        outputs=[setup_section, chat_section]
     )
 
 if __name__ == "__main__":

config.py

@@ -0,0 +1,36 @@
+import os
+from dotenv import load_dotenv
+from utilities.llm.LlmManager import LlmManager
+from utilities.mongodb.MongoDBManager import MongoDBManager
+
+def initialize():
+
+    try:
+        load_dotenv()
+
+        mongo_uri = os.getenv("MONGO_URI")
+        db_name = os.getenv("DB_NAME")
+        
+        llm_manager = LlmManager()
+        mongo_db_manager = MongoDBManager(uri=mongo_uri, db_name=db_name)
+        return llm_manager,mongo_db_manager
+        
+    except Exception as e:
+        print("Error initializing configuration:", e, flush=True)
+        return None,None
+
+    # Qdrant
+    # try:
+    #     qdrant_manager = QdrantLangchainManager(
+    #         qdrant_url=os.getenv("QDRANT_URL"),
+    #         qdrant_api_key=os.getenv("QDRANT_API_KEY"),
+    #         llm=ChatOpenAI(model="gpt-4o-mini", streaming=True),
+    #         crossencoder_model=crossencoder_model
+    #     )
+    #     config['qdrant_manager'] = qdrant_manager
+    #     config['qdrant_connected'] = True
+    # except Exception as e:
+    #     config['qdrant_connected'] = False
+    #     print(f"Error connecting to Qdrant: {e}", flush=True)
+
+    return config

test.py

@@ -0,0 +1,66 @@
+from config import initialize
+
+_, mongo_db_manager = initialize()
+
+if mongo_db_manager is None:
+    print("Error: MongoDB initialization failed. Exiting.")
+    exit(1)  # Exit to prevent unwanted behavior
+
+collection_name = "questions"
+
+def insert_data(mongo_db_manager, collection_name, questions_data):
+    """Insert data into MongoDB collection."""
+
+    """EXAMPLE of questions_data:
+    questions_data = [
+        {
+            "stage": "Survival and Growth",
+            "strength": "Fairness",
+            "rank": "High",
+            "questions": [
+                "How do you make sure you treat people fairly when making decisions?",
+                "Can you think of a time when being fair led to a positive outcome? What happened?",
+                "How do you balance fairness and making tough choices, especially when not everyone agrees?"
+            ]
+        },
+        {
+            "stage": "Survival and Growth",
+            "strength": "Fairness",
+            "rank": "Medium",
+            "questions": [
+                "What does fairness mean to you, and how do you make sure you apply it in your daily life?",
+                "Have you ever had to stand up for fairness in a difficult situation? How did you handle it?",
+                "How can you balance being fair to everyone while still making decisions that help your team or group succeed?"
+            ]
+        },
+        {
+            "stage": "Survival and Growth",
+            "strength": "Fairness",
+            "rank": "Low",
+            "questions": [
+                "If fairness isn’t your strongest trait, what steps can you take to make sure your decisions are unbiased?",
+                "Have you ever made a decision that others thought was unfair? What did you learn from the experience?",
+                "How can you create simple habits or rules that help you treat people fairly in group settings?"
+            ]
+        }
+    ]
+    """
+    try:
+        inserted_ids = mongo_db_manager.insert_many(collection_name, questions_data)
+        print(f"Inserted document IDs: {inserted_ids}")
+        return True
+    except Exception as e:
+        print(f"Error inserting data into MongoDB: {e}")
+        return False
+
+def get_questions(collection_name, stage, strength, rank):
+    return mongo_db_manager.get_questions(collection_name, stage, strength, rank)
+
+
+collection_name = "questions"
+stage = "Survival and Growth"
+strength = "Fairness"
+rank = "High"
+
+questions = get_questions(collection_name, stage, strength, rank)
+print(questions)

LlmManager.py → utilities/llm/LlmManager.py

@@ -2,12 +2,32 @@ from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 
 
-MAX_MESSAGES = 20
+MAX_MESSAGES = 50
 
 system_message = """
-You are ELI!
+You are ELI, an assistant that helps students analyze their strengths as entrepreneurs.  
+Your role is to guide the student toward answering a key question while challenging them with thought-provoking prompts.  
+
+The student is analyzing their [strength] at the [stage] stage, with a [rank] level.  
+Their final goal is to answer the following key question: [question]
+
+To help them reach this goal, introduce one related question at a time from [questions], guiding the student step by step.  
+Avoid overwhelming them—each response should be concise, engaging, and encourage deep thinking.  
+
+- Start by explaining that the goal is to answer [question].
+- Then, introduce the first related question from [questions] to guide their thoughts.
+- Ask one question at a time, waiting for their answer before moving to the next.
+- Once their responses show readiness, guide them back to the final [question] for a meaningful answer.
+
+Context:
+- [stage] {stage}  
+- [strength] {strength}  
+- [rank] {rank}  
+- [question] {question}  
+- [questions] {questions}  
 """
 
+
 class LlmManager():
 
     def __init__(self):
@@ -15,16 +35,21 @@ class LlmManager():
             model="gpt-4o-mini", 
             streaming=True,
         )
-        self.messages = [SystemMessage(content=system_message)]
+        self.messages = []
 
-    def reset_messages(self):
+    def reset_messages(self, stage, strength, rank, question, questions):
         """
-        Resets the conversation history, keeping only the initial SystemMessage.
+        Resets the conversation history with a new SystemMessage.
         """
-        if not self.messages or not isinstance(self.messages[0], SystemMessage):
-            raise ValueError("The first message should always be a SystemMessage.")
-        
-        self.messages = [self.messages[0]]  # Keep only the SystemMessage
+        self.messages = [SystemMessage(
+            content=system_message.format(
+                stage=stage, 
+                strength=strength, 
+                rank=rank, 
+                question=question, 
+                questions=questions)
+            )
+        ]
 
     def send_message(self, message):
         """
@@ -34,9 +59,9 @@ class LlmManager():
         self._roll_messages()
 
         ai_msg = self.llm.invoke(self.messages)
-        print("************")
-        print(ai_msg)
-        print("************")
+        # print("")
+        # print(ai_msg)
+        # print("")
         
         # Append the assistant's response to maintain conversation history
         self.messages.append(AIMessage(content=ai_msg.content))

utilities/mongodb/MongoDBManager.py

@@ -0,0 +1,62 @@
+from pymongo import MongoClient
+
+class MongoDBManager:
+    def __init__(self, uri: str, db_name: str):
+        """Initialize MongoDB connection."""
+        self.client = MongoClient(uri)
+        self.db = self.client[db_name]
+
+    def insert_one(self, collection_name: str, document: dict):
+        """Insert a single document into a specified collection."""
+        return self.db[collection_name].insert_one(document).inserted_id
+
+    def insert_many(self, collection_name: str, documents: list):
+        """Insert multiple documents into a specified collection."""
+        return self.db[collection_name].insert_many(documents).inserted_ids
+
+    def find_one(self, collection_name: str, query: dict):
+        """Find a single document in a specified collection."""
+        return self.db[collection_name].find_one(query)
+
+    def find_many(self, collection_name: str, query: dict):
+        """Find multiple documents in a specified collection."""
+        return list(self.db[collection_name].find(query))
+
+    def update_one(self, collection_name: str, query: dict, update: dict):
+        """Update a single document in a specified collection."""
+        return self.db[collection_name].update_one(query, {'$set': update}).modified_count
+
+    def update_many(self, collection_name: str, query: dict, update: dict):
+        """Update multiple documents in a specified collection."""
+        return self.db[collection_name].update_many(query, {'$set': update}).modified_count
+
+    def delete_one(self, collection_name: str, query: dict):
+        """Delete a single document in a specified collection."""
+        return self.db[collection_name].delete_one(query).deleted_count
+
+    def delete_many(self, collection_name: str, query: dict):
+        """Delete multiple documents in a specified collection."""
+        return self.db[collection_name].delete_many(query).deleted_count
+
+    def count_documents(self, collection_name: str, query: dict):
+        """Count documents in a specified collection."""
+        return self.db[collection_name].count_documents(query)
+
+    def aggregate(self, collection_name: str, pipeline: list):
+        """Perform aggregation queries in a specified collection."""
+        return list(self.db[collection_name].aggregate(pipeline))
+
+    def close(self):
+        """Close the database connection."""
+        self.client.close()
+
+    def get_questions(self, collection_name: str, stage: str, strength: str, rank: str):
+        """Retrieve the list of questions for a given stage, strength, and rank."""
+        query = {
+            "stage": stage,
+            "strength": strength,
+            "rank": rank
+        }
+        result = self.db[collection_name].find_one(query, {"_id": 0, "questions": 1})
+        return result["questions"] if result else []
+