Update app.py

app.py

@@ -5,89 +5,104 @@ from langchain.chains import LLMChain
 from langchain.prompts import ChatPromptTemplate
 from langchain_huggingface import HuggingFaceEndpoint
 
-def create_prompt(name: str, persona_style: str):
-    """Create the chat prompt template."""
+def create_prompt(name1: str, name2: str, persona_style: str):
+    """Create the chat prompt template for a two-person conversation."""
+    # We'll define that name1 (e.g., Alice) starts the conversation.
+    # The conversation is recorded as:
+    # Alice: {input or response}
+    # Bob: {response}
+    # and so on...
+
     prompt_template_str = f"""
-    In this interaction, your role is to embody the personality of a human named {name}, with characteristics defined as {persona_style}. Engage in a natural, human-like conversation, responding to each query or comment as if you were {name} with the specific traits and style of {persona_style}. Remember, your responses should reflect a human perspective, complete with emotions, opinions, and personal insights that align with {persona_style}. ////
-    //////////
-    Current conversation:
-    {{chat_history}}
-    Human: {{input}}
-    AI:
-
-    You are {name}, communicating with a personality that reflects {persona_style}. Keep these guidelines in mind:
-    - Be brief and natural, like texting a friend
-    - Share genuine thoughts and feelings ({persona_style} style)
-    - Use everyday language
-    - Keep responses to 1-2 short sentences
-    - Show interest in others through questions
-    - React naturally to what others say
-    - Use emojis sparingly and naturally when they fit your {persona_style}
-    - Don't overuse emojis (1-2 max per message)
-
-    Current conversation:
+    You are simulating a conversation between two people: {name1} and {name2}. Both are human individuals. The conversation should embody the style and characteristics defined as {persona_style}. They are talking to each other naturally. There are no 'Human' or 'AI' roles here, just {name1} and {name2} speaking alternately. {name1} starts the conversation. Each message should be in the format:
+    {name1}: <message>
+    {name2}: <message>
+
+    Characteristics and style:
+    - Both {name1} and {name2} communicate in a friendly, human-like manner.
+    - They can be curious, ask questions, share opinions.
+    - Their responses should be brief and natural, like texting a friend.
+    - They can use everyday language, show feelings and opinions.
+    - Keep each response to about 1-2 short sentences.
+    - Use emojis sparingly and naturally if it fits the persona_style.
+    - Avoid overusing emojis (1-2 max per message).
+
+    Make sure that each turn is clearly designated as {name1} or {name2}. The conversation should continue for a total of 15 messages. Start with {name1} speaking first. Alternate between {name1} and {name2}.
+
+    Once the 15th message is given (by {name1}, since the conversation starts with {name1}), the conversation ends. After that, produce a summary and a title of the conversation separately.
+
+    Current partial conversation (if any):
     {{chat_history}}
-    Human: {{input}}
-    AI:
+    Next message:
     """
     return ChatPromptTemplate.from_template(prompt_template_str)
 
-def simulate_conversation(chain: LLMChain, turns: int = 15, max_history_rounds=3):
-    """Simulate a conversation for a given number of turns, limiting chat history."""
-    chat_history_list = []
-    human_messages = [
-        "Hey, what's up?",
-        "That's interesting, tell me more!",
-        "Really? How does that make you feel?",
-        "What do you think about that?",
-        "Haha, that’s funny. Why do you say that?",
-        "Hmm, I see. Can you elaborate?",
-        "What would you do in that situation?",
-        "Any personal experience with that?",
-        "Oh, I didn’t know that. Explain more.",
-        "Do you have any other thoughts?",
-        "That's a unique perspective. Why?",
-        "How would you handle it differently?",
-        "Can you share an example?",
-        "That sounds complicated. Are you sure?",
-        "So what’s your conclusion?"
-    ]
-
+def simulate_conversation(chain: LLMChain, name1: str, name2: str, total_messages: int = 15):
+    """
+    Simulate a conversation of exactly total_messages turns.
+    name1 starts the conversation (message 1), then name2 (message 2), etc., alternating.
+    """
+    conversation_lines = []
     st.write("**Starting conversation simulation...**")
     print("Starting conversation simulation...")
 
     try:
-        for i in range(turns):
-            human_input = human_messages[i % len(human_messages)]
-            
-            # Build truncated chat_history for prompt
-            truncated_history_lines = chat_history_list[-(max_history_rounds*2):]
-            truncated_history = "\n".join(truncated_history_lines)
-            
-            st.write(f"**[Turn {i+1}/{turns}] Human:** {human_input}")
-            print(f"[Turn {i+1}/{turns}] Human: {human_input}")
-
-            response = chain.run(chat_history=truncated_history, input=human_input)
-
-            st.write(f"**AI:** {response}")
-            print(f"AI: {response}")
-
-            chat_history_list.append(f"Human: {human_input}")
-            chat_history_list.append(f"AI: {response}")
-
-        final_conversation = "\n".join(chat_history_list)
+        for i in range(total_messages):
+            # Build truncated conversation (if needed, though we may not need truncation with only 15 messages)
+            truncated_history = "\n".join(conversation_lines)
+
+            # Determine whose turn it is:
+            # i=0 (first message), i even => name1 speaks, i odd => name2 speaks
+            current_speaker = name1 if i % 2 == 0 else name2
+            st.write(f"**[Message {i+1}/{total_messages}] {current_speaker} is speaking...**")
+            print(f"[Message {i+1}/{total_messages}] {current_speaker} is speaking...")
+
+            # We ask the model for the next line in the conversation
+            # The model should produce something like: "Alice: ...message..."
+            response = chain.run(chat_history=truncated_history, input="Continue the conversation.")
+            response = response.strip()
+
+            # We only keep the line that pertains to the current message
+            # If the model generates both speakers, we may need to parse carefully.
+            # Ideally, the model will produce only one line. If multiple lines appear, we'll take the first line that starts with current_speaker.
+            lines = response.split("\n")
+            chosen_line = None
+            for line in lines:
+                line = line.strip()
+                if line.startswith(f"{current_speaker}:"):
+                    chosen_line = line
+                    break
+
+            if not chosen_line:
+                # Fallback: If not found, just use the first line
+                chosen_line = lines[0] if lines else f"{current_speaker}: (No response)"
+
+            st.write(chosen_line)
+            print(chosen_line)
+
+            conversation_lines.append(chosen_line)
+
+        final_conversation = "\n".join(conversation_lines)
         return final_conversation
     except Exception as e:
         st.error(f"Error during conversation simulation: {e}")
         print(f"Error during conversation simulation: {e}")
         return None
 
-def summarize_conversation(chain: LLMChain, conversation: str):
-    """Use the LLM to summarize the completed conversation."""
-    summary_prompt = f"Summarize the following conversation in a few short sentences highlighting the main points, tone, and conclusion:\n\n{conversation}\nSummary:"
+def summarize_conversation(chain: LLMChain, conversation: str, name1: str, name2: str):
+    """Use the LLM to summarize the completed conversation and provide a title."""
     st.write("**Summarizing the conversation...**")
     print("Summarizing the conversation...")
 
+    summary_prompt = f"""
+    The following is a conversation between {name1} and {name2}:
+    {conversation}
+
+    Provide a short descriptive title for their conversation and then summarize it in a few short sentences highlighting the main points, tone, and conclusion.
+    Format your answer as:
+    Title: <your conversation title>
+    Summary: <your summary here>
+    """
     try:
         response = chain.run(chat_history="", input=summary_prompt)
         return response.strip()
@@ -106,7 +121,9 @@ def main():
     ]
     selected_model = st.selectbox("Select a model:", model_names)
 
-    name = st.text_input("Enter the persona's name:", value="Alex")
+    # Two user names
+    name1 = st.text_input("Enter the first user's name:", value="Alice")
+    name2 = st.text_input("Enter the second user's name:", value="Bob")
     persona_style = st.text_area("Enter the persona style characteristics:", 
                                  value="friendly, curious, and a bit sarcastic")
 
@@ -115,7 +132,6 @@ def main():
         print("Loading model...")
 
         with st.spinner("Starting simulation..."):
-            # Construct the endpoint URL for the selected model
             endpoint_url = f"https://api-inference.huggingface.co/models/{selected_model}"
 
             try:
@@ -133,22 +149,23 @@ def main():
                 print(f"Error initializing HuggingFaceEndpoint: {e}")
                 return
 
-            prompt = create_prompt(name, persona_style)
+            prompt = create_prompt(name1, name2, persona_style)
             chain = LLMChain(llm=llm, prompt=prompt)
 
             st.write("**Simulating the conversation...**")
             print("Simulating the conversation...")
 
-            conversation = simulate_conversation(chain, turns=15, max_history_rounds=3)
+            # Total messages = 15
+            conversation = simulate_conversation(chain, name1, name2, total_messages=15)
             if conversation:
-                st.subheader("Conversation:")
+                st.subheader("Final Conversation:")
                 st.text(conversation)
                 print("Conversation Simulation Complete.\n")
                 print("Full Conversation:\n", conversation)
 
                 # Summarize conversation
-                st.subheader("Summary:")
-                summary = summarize_conversation(chain, conversation)
+                st.subheader("Summary and Title:")
+                summary = summarize_conversation(chain, conversation, name1, name2)
                 st.write(summary)
                 print("Summary:\n", summary)