Update app.py

app.py

@@ -6,92 +6,39 @@ from langchain.prompts import ChatPromptTemplate
 from langchain_huggingface import HuggingFaceEndpoint
 
 def create_prompt(name1: str, name2: str, persona_style: str):
-    """Create the chat prompt template for a two-person conversation."""
+    """Create a prompt that instructs the model to produce all 15 messages at once."""
     prompt_template_str = f"""
-    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.
-    - Responses should be brief and natural, like texting a friend.
-    - Use everyday language, show feelings and opinions.
-    - Keep each response to about 1-2 short sentences.
-    - Use emojis sparingly and only 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 (by {name1}) is given, the conversation ends.
-    Do not continue the conversation after 15 messages.
+    You are to simulate a conversation of exactly 15 messages total between two people: {name1} and {name2}.
+    The conversation should reflect the style: {persona_style}.
+    {name1} speaks first (message 1), {name2} responds (message 2), then {name1} (message 3), and so on, alternating until 15 messages are complete.
+    Rules:
+    - Each message should be written as:
+      {name1}: <message> or {name2}: <message>
+    - Each message should be 1-2 short sentences, friendly, and natural.
+    - Keep it casual, can ask questions, share opinions.
+    - Use emojis sparingly if it fits the persona (no more than 1-2 per message).
+    - Do not repeat the same line over and over.
+    - The conversation must flow logically and naturally.
+    - After producing exactly 15 messages (the 15th message by {name1}), stop. Do not add anything else.
+    - Do not continue the conversation beyond 15 messages.
+    
+    Produce all 15 messages now:
     """
     return ChatPromptTemplate.from_template(prompt_template_str)
 
-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(total_messages):
-            truncated_history = "\n".join(conversation_lines)
-            # Determine whose turn it is:
-            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...")
-
-            # Prompt the chain with a generic "continue" instruction, the chain uses the template + history to produce the next message
-            response = chain.run(chat_history=truncated_history, input="Continue the conversation.")
-            response = response.strip()
-
-            # Extract the line for the 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 the model didn't format properly, try first non-empty line
-                chosen_line = next((l for l in lines if l.strip()), 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, name1: str, name2: str):
-    """Use the LLM to summarize the completed conversation and provide a title."""
+    """Summarize the completed conversation."""
     st.write("**Summarizing the conversation...**")
     print("Summarizing the conversation...")
 
-    # Updated prompt: no continuation instructions, just a direct request.
     summary_prompt = f"""
     Below is a completed conversation between {name1} and {name2}:
     {conversation}
 
-    Now that the conversation has ended, please provide:
-    1. A short and descriptive title of the conversation on one line, starting with "Title:".
-    2. A summary of the conversation on the next line, starting with "Summary:".
-    The summary should be a few short sentences highlighting the main points, tone, and conclusion.
-    Do not continue the conversation. Do not add extra lines beyond the title and summary.
+    Please provide:
+    Title: <A short descriptive title of the conversation>
+    Summary: <A few short sentences highlighting the main points, tone, and conclusion of the conversation>
+    Do not continue the conversation, just provide the title and summary.
     """
 
     try:
@@ -112,7 +59,6 @@ def main():
     ]
     selected_model = st.selectbox("Select a model:", model_names)
 
-    # 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:", 
@@ -131,7 +77,7 @@ def main():
                     huggingfacehub_api_token=os.environ.get("HUGGINGFACEHUB_API_TOKEN"),
                     task="text-generation",
                     temperature=0.7,
-                    max_new_tokens=256 # Reduced tokens for faster response
+                    max_new_tokens=512
                 )
                 st.write("**Model loaded successfully!**")
                 print("Model loaded successfully!")
@@ -143,21 +89,29 @@ def main():
             prompt = create_prompt(name1, name2, persona_style)
             chain = LLMChain(llm=llm, prompt=prompt)
 
-            st.write("**Simulating the conversation...**")
-            print("Simulating the conversation...")
+            st.write("**Generating the full 15-message conversation...**")
+            print("Generating the full 15-message conversation...")
 
-            conversation = simulate_conversation(chain, name1, name2, total_messages=15)
-            if conversation:
+            try:
+                # Generate all 15 messages in one go
+                conversation = chain.run(chat_history="", input="Produce the full conversation now.")
+                conversation = conversation.strip()
+                
+                # Print and display the conversation
                 st.subheader("Final Conversation:")
                 st.text(conversation)
-                print("Conversation Simulation Complete.\n")
+                print("Conversation Generation Complete.\n")
                 print("Full Conversation:\n", conversation)
 
-                # Summarize conversation
+                # Summarize the conversation
                 st.subheader("Summary and Title:")
                 summary = summarize_conversation(chain, conversation, name1, name2)
                 st.write(summary)
                 print("Summary:\n", summary)
 
+            except Exception as e:
+                st.error(f"Error generating conversation: {e}")
+                print(f"Error generating conversation: {e}")
+
 if __name__ == "__main__":
     main()