add: sample agentic chat experiment

sample_chat.py

@@ -1,118 +1,90 @@
 import gradio as gr
-from dataclasses import asdict
-from transformers import Tool, ReactCodeAgent  # type: ignore
-from transformers.agents import stream_to_gradio, HfApiEngine  # type: ignore
-
-from gradio_tools import GradioTool  # assuming you have gradio_tool installed
-
-class GenerateQuestionsTool(GradioTool):
-    """
-    A tool to generate general questions for deployment/integration gaps.
-    The tool calls the execute_prompt method using the "generate_general_questions" prompt.
-    Input: (optional) project detail as a string.
-    Output: Generated questions as a string.
+from gradio import ChatMessage
+import time
+
+sleep_time = 0.2
+
+# ... existing code ...
+
+def get_client_information_questions():
+    """Return client information gathering questions."""
+    return """
+    # Client Information Gathering Questions
+        
+    ### Company Background and Industry
+    1. Can you provide some background about your company?
+    2. Which industry do you operate in, and what is your company's niche or specialization?
+    3. Who are your primary customers?
+    4. What are the main objectives you want to achieve?
+    5. What key features or functionalities do you need?
+        
+    ### Current Challenges
+    6. What are the biggest challenges your firm is currently facing?
+    7. Can you describe your current processes?
+        
+    ### Workflow and System Impact
+    8. How will this solution benefit your firm as a whole?
+        
+    ### Existing Workflow or System
+    9. Can you describe your current workflow or system?
+        
+    ### Pain Point Identification
+    10. Where is your current system falling short or causing delays?
+    11. Are there any parts of the process that are particularly time-consuming/ prone to error?
     """
-    def __init__(
-        self,
-        name="GenerateQuestions",
-        description=(
-            "A tool that generates general deployment/integration questions "
-            "by executing a prompt with project details. "
-            "Input: a string with project detail (optional). Output: a string with generated questions."
-        ),
-        src="",  # Replace with your actual Gradio space id or URL if needed
-    ):
-        super().__init__(name, description, src)
-        # Optionally, you could initialize any state or dependencies here
-
-    def create_job(self, query: str):
-        """
-        This method interprets the input query.
-        In our case, if a query is provided, we use it as project_detail;
-        otherwise, we rely on the internal method get_project_detail().
-        """
-        # Assuming your tool's class (or the project instance) has these methods.
-        project_detail = query if query.strip() else self.get_project_detail()
-        try:
-            # Execute the prompt with provided project detail.
-            result = self.execute_prompt("generate_general_questions", {"project_detail": project_detail})
-        except Exception as e:
-            result = f"Error during prompt execution: {str(e)}"
-        return result
-
-    def postprocess(self, output) -> str:
-        """
-        Process the output from the job to a string that can be returned to the LLM.
-        """
-        return str(output)
-
-    def _block_input(self, gr):
-        """
-        Define the Gradio input component.
-        Here, we use a textbox where the user can optionally provide project details.
-        """
-        return gr.Textbox(label="Project Detail (optional)", placeholder="Enter project detail or leave empty to use default")
-
-    def _block_output(self, gr):
-        """
-        Define the Gradio output component.
-        We return the generated questions in a textbox.
-        """
-        return gr.Textbox(label="Generated Questions")
-
-
-from langchain.agents import initialize_agent
-from langchain.llms import OpenAI
-from dotenv import load_dotenv
-
-load_dotenv()
-
-llm = OpenAI(temperature=0)
-tools = [GenerateQuestionsTool().langchain]  # assuming your tool is properly integrated
-
-
-agent = initialize_agent(tools, llm, agent="conversational agent", verbose=True)
-output = agent.run(input="Please generate integration questions for my project")
-print(output)
-
-# # Import tool from Hub
-# image_generation_tool = Tool.from_space(  # type: ignore
-#     space_id="black-forest-labs/FLUX.1-schnell",
-#     name="image_generator",
-#     description="Generates an image following your prompt. Returns a PIL Image.",
-#     api_name="/infer",
-# )
-
-# llm_engine = HfApiEngine("Qwen/Qwen2.5-Coder-32B-Instruct")
-# # Initialize the agent with both tools and engine
-# agent = ReactCodeAgent(tools=[image_generation_tool], llm_engine=llm_engine)
-
-
-# def interact_with_agent(prompt, history):
-#     messages = []
-#     yield messages
-#     for msg in stream_to_gradio(agent, prompt):
-#         messages.append(asdict(msg))  # type: ignore
-#         yield messages
-#     yield messages
-
-
-# demo = gr.ChatInterface(
-#     interact_with_agent,
-#     chatbot= gr.Chatbot(
-#         label="Agent",
-#         type="messages",
-#         avatar_images=(
-#             None,
-#             "https://em-content.zobj.net/source/twitter/53/robot-face_1f916.png",
-#         ),
-#     ),
-#     examples=[
-#         ["Generate an image of an astronaut riding an alligator"],
-#         ["I am writing a children's book for my daughter. Can you help me with some illustrations?"],
-#     ],
-#     type="messages",
-# )
 
-# if __name__ == "__main__":
-#     demo.launch()
+def simulate_thinking_chat(message, history):
+    start_time = time.time()
+    response = ChatMessage(
+        content="",
+        metadata={"title": "_Thinking_ step-by-step", "id": 0, "status": "pending"}
+    )
+    yield response
+
+    thoughts = [
+        "First, I need to understand the core aspects of the query...",
+        "Now, considering the broader context and implications...",
+        "Analyzing potential approaches to formulate a comprehensive answer...",
+        "Finally, structuring the response for clarity and completeness..."
+    ]
+
+    accumulated_thoughts = ""
+    for thought in thoughts:
+        time.sleep(sleep_time)
+        accumulated_thoughts += f"- {thought}\n\n"
+        response.content = accumulated_thoughts.strip()
+        yield response
+
+    response.metadata["status"] = "done"
+    response.metadata["duration"] = time.time() - start_time
+    yield response
+
+    # Prepare the final response list
+    response_list = [
+        response,
+        ChatMessage(
+            content=get_client_information_questions()
+        )
+    ]
+    print(f"Message: {message},\n Len: {len(history)}, \nHistory: {history}")
+
+    # Print the response list to the console
+    # print(response_list)
+
+    yield response_list
+
+chatbot = gr.Chatbot(height=650 ,elem_classes=["chatbot-container"])
+
+
+with gr.Blocks(fill_height=True) as demo:
+    gr.ChatInterface(
+        simulate_thinking_chat,
+        title="Thinking LLM Chat Interface 🤔",
+        type="messages",
+        fill_height=True,
+        chatbot= chatbot,
+        # show_progress= 'minimal',
+        # save_history= True
+    )
+
+demo.launch()