o1 Type Considering with Chain-of-Thought Reasoning utilizing Mirascope

!pip set up "mirascope[groq]" 
!pip set up datetime

from typing import Literal

from mirascope.core import groq
from pydantic import BaseModel, Area


historical past: listing[dict] = []


class COTResult(BaseModel):
    title: str = Area(..., desecription="The title of the step")
    content material: str = Area(..., description="The output content material of the step")
    next_action: Literal["continue", "final_answer"] = Area(
        ..., description="The following motion to take"
    )

@groq.name("llama-3.3-70b-versatile", json_mode=True, response_model=COTResult)
def cot_step(immediate: str, step_number: int, previous_steps: str) -> str:
    return f"""
    You're an skilled AI assistant that explains your reasoning step-by-step.
    For this step, present a title that describes what you are doing, together with the content material.
    Determine in the event you want one other step or in the event you're prepared to provide the ultimate reply.

    Tips:
    - Use AT MOST 5 steps to derive the reply.
    - Concentrate on your limitations as an LLM and what you possibly can and can't do.
    - In your reasoning, embrace exploration of different solutions.
    - Think about chances are you'll be improper, and in case you are improper in your reasoning, the place it will be.
    - Absolutely take a look at all different prospects.
    - YOU ARE ALLOWED TO BE WRONG. Whenever you say you might be re-examining
        - Really re-examine, and use one other method to take action.
        - Don't simply say you might be re-examining.

    IMPORTANT: Don't use code blocks or programming examples in your reasoning. Clarify your course of in plain language.

    That is step quantity {step_number}.

    Query: {immediate}

    Earlier steps:
    {previous_steps}
    """


@groq.name("llama-3.3-70b-versatile")
def final_answer(immediate: str, reasoning: str) -> str:
    return f"""
    Based mostly on the next chain of reasoning, present a last reply to the query.
    Solely present the textual content response with none titles or preambles.
    Retain any formatting as instructed by the unique immediate, resembling precise formatting at no cost response or a number of selection.

    Query: {immediate}

    Reasoning:
    {reasoning}

    Last Reply:
    """

def generate_cot_response(
    user_query: str,
) -> tuple[list[tuple[str, str, float]], float]:
    steps: listing[tuple[str, str, float]] = []
    total_thinking_time: float = 0.0
    step_count: int = 1
    reasoning: str = ""
    previous_steps: str = ""

    whereas True:
        start_time: datetime = datetime.now()
        cot_result = cot_step(user_query, step_count, previous_steps)
        end_time: datetime = datetime.now()
        thinking_time: float = (end_time - start_time).total_seconds()

        steps.append(
            (
                f"Step {step_count}: {cot_result.title}",
                cot_result.content material,
                thinking_time,
            )
        )
        total_thinking_time += thinking_time

        reasoning += f"n{cot_result.content material}n"
        previous_steps += f"n{cot_result.content material}n"

        if cot_result.next_action == "final_answer" or step_count >= 5:
            break

        step_count += 1

    # Generate last reply
    start_time = datetime.now()
    final_result: str = final_answer(user_query, reasoning).content material
    end_time = datetime.now()
    thinking_time = (end_time - start_time).total_seconds()
    total_thinking_time += thinking_time

    steps.append(("Last Reply", final_result, thinking_time))

    return steps, total_thinking_time


def display_cot_response(
    steps: listing[tuple[str, str, float]], total_thinking_time: float
) -> None:
    for title, content material, thinking_time in steps:
        print(f"{title}:")
        print(content material.strip())
        print(f"**Considering time: {thinking_time:.2f} seconds**n")

    print(f"**Whole considering time: {total_thinking_time:.2f} seconds**")

def run() -> None:
    query: str = "If a practice leaves Metropolis A at 9:00 AM touring at 60 km/h, and one other practice leaves Metropolis B (which is 300 km away from Metropolis A) at 10:00 AM touring at 90 km/h towards Metropolis A, at what time will the trains meet?"
    print("(Consumer):", query)
    # Generate COT response
    steps, total_thinking_time = generate_cot_response(query)
    display_cot_response(steps, total_thinking_time)

    # Add the interplay to the historical past
    historical past.append({"position": "person", "content material": query})
    historical past.append(
        {"position": "assistant", "content material": steps[-1][1]}
    )  # Add solely the ultimate reply to the historical past


# Run the operate

run()