Develop "Context-Aware Dynamic Memory CoT" (CADM-CoT). CADM-CoT introduces a dynamic memory module that actively maintains a short-term memory buffer of previously generated reasoning steps and user-provided context. This memory is contextually queried during reasoning to simulate a more "human-like" working memory that adapts dynamically to the problem at hand. Integrate into the script:

```
import streamlit as st
import g4f
from g4f.client import Client
import os
import json
import time

client = Client()

def make_api_call(messages, max_tokens, is_final_answer=False):
    for attempt in range(3):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",  # Adjust the model as needed
                messages=messages,
                max_tokens=max_tokens,
                temperature=0.2,
                response_format={"type": "json_object"}
            )
            return json.loads(response.choices[0].message.content)
        except Exception as e:
            if attempt == 2:
                error_content = f"Failed to generate {'final answer' if is_final_answer else 'step'} after 3 attempts. Error: {str(e)}"
                return {
                    "title": "Error",
                    "content": error_content,
                    "next_action": "final_answer" if is_final_answer else "continue"
                }
            time.sleep(1)  # Wait for 1 second before retrying

def generate_response(prompt):
    messages = [
        {
            "role": "system",
            "content": """You are an advanced analytical AI assistant with adaptive capabilities to thoroughly analyze complex problems. Your task is to provide detailed, step-by-step explanations of your thought process using advanced analytical methods, adaptive reasoning, and advanced common-sense reasoning. For each step:

1. **Advanced Analysis**: Apply sophisticated analytical techniques to dissect the problem.
2. **Adaptive Reasoning**: Reflect on previous steps to adjust your approach based on new insights or information.
3. **Common-Sense Reasoning**: Utilize everyday knowledge and logical reasoning to fill in gaps and make sound judgments.
4. **In-depth Exploration**: Explore multiple dimensions and perspectives of the problem.
5. **Critical Evaluation**: Critically evaluate your findings and adjust hypotheses accordingly.

**Response Format:**
Use JSON with keys:
- `"title"`: A clear, concise title describing the current reasoning phase.
- `"content"`: Elaborate on your thought process in this step.
- `"next_action"`: Decide whether to `"continue"` reasoning or provide a `"final_answer"`.

**Key Instructions:**
- Employ at least 5 distinct reasoning steps.
- In each step, explicitly reference relevant parts of previous steps to adapt your reasoning.
- Use advanced analytical methods (e.g., statistical analysis, logical deductions, scenario planning).
- Apply advanced common-sense reasoning to make logical inferences and fill in gaps in information.
- Adapt your reasoning strategies based on the complexity and nuances of the problem.
- Acknowledge your limitations and explicitly state what you can and cannot do.
- Evaluate alternative answers or approaches thoroughly.
- Critically assess your reasoning; identify potential flaws or biases.
- Ensure that your explanations are consistent and coherent throughout the reasoning process.
- Utilize diverse methods to derive or verify your answer.
- Incorporate relevant domain knowledge and best practices.
- Quantify certainty levels for each step and the final conclusion when applicable.
- Consider potential edge cases, exceptions, or unintended consequences.
- Provide clear justifications for eliminating alternative hypotheses.

**Example of a valid JSON response:**
```json
{
    "title": "Advanced Statistical Analysis",
    "content": "I will perform a statistical analysis to determine... [detailed explanation]... This will help quantify the relationships between variables.",
    "next_action": "continue"
}```
"""
            },
        {"role": "user", "content": prompt},
        {
            "role": "assistant",
            "content": "Understood. I will proceed to analyze the problem using advanced analytical methods, adaptive reasoning, and common-sense reasoning."
        }
    ]

    steps = []
    step_count = 1
    total_thinking_time = 0

    summary_of_steps = ""

    while True:
        start_time = time.time()
        # Add summary of previous steps to the messages
        if summary_of_steps:
            messages.append({"role": "user", "content": f"Summary of previous steps:\n{summary_of_steps}"})

        step_data = make_api_call(messages, 800)
        end_time = time.time()
        thinking_time = end_time - start_time
        total_thinking_time += thinking_time

        # Update summary of steps for assistant to adapt reasoning
        summary_of_steps += f"Step {step_count} ({step_data['title']}): {step_data['content']}\n\n"

        steps.append((f"Step {step_count}: {step_data['title']}", step_data['content'], thinking_time))

        # Add the assistant's response to the message history
        messages.append({"role": "assistant", "content": json.dumps(step_data)})

        if step_data.get('next_action', '') == 'final_answer':
            break

        step_count += 1

        # Yield after each step for Streamlit to update
        yield steps, None  # Total time is yielded at the end

    # Generate final answer
    messages.append({"role": "user", "content": "Please provide the final answer based on your reasoning above."})

    start_time = time.time()
    final_data = make_api_call(messages, 500, is_final_answer=True)
    end_time = time.time()
    thinking_time = end_time - start_time
    total_thinking_time += thinking_time

    steps.append(("Final Answer", final_data['content'], thinking_time))

    yield steps, total_thinking_time

def main():
    st.set_page_config(page_title="Adaptive AI Reasoning Chains", page_icon="🧠", layout="wide")

    st.title("Adaptive AI Assistant with Advanced Analytical and Common-Sense Capabilities")

    st.markdown("""
This application utilizes an adaptive AI assistant that applies advanced analytical methods and common-sense reasoning to thoroughly analyze complex problems.
        
Forked from [bklieger-groq](https://github.com/bklieger-groq)
        
Open source [repository here](https://github.com/win4r/o1)
""")

    # Text input for user query
    user_query = st.text_input(
        "Enter a complex problem for analysis:",
        placeholder="e.g., Analyze the potential impacts of implementing a universal basic income."
    )

    if user_query:
        st.write("Generating response...")

        # Create empty elements to hold the generated text and total time
        response_container = st.empty()
        time_container = st.empty()

        # Generate and display the response
        for steps, total_thinking_time in generate_response(user_query):
            with response_container.container():
                for i, (title, content, thinking_time) in enumerate(steps):
                    if title.startswith("Final Answer"):
                        st.markdown(f"### {title}")
                        st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
                    else:
                        with st.expander(title, expanded=False):
                            st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)

            # Only show total time when it's available at the end
            if total_thinking_time is not None:
                time_container.markdown(f"**Total thinking time: {total_thinking_time:.2f} seconds**")

if __name__ == "__main__":
    main()