## 模型搭建準備
import ollama
llm = "qwen2.5"

## 提問
q = "What is 30 multiplied by 10?"

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content':q}
])
print(response['message']['content'])

prompt = '''
To solve the task, you must plan forward to proceed in a series of steps, in a cycle of 'Thought:', 'Action:', and 'Observation:' sequences.
At each step, in the 'Thought:' sequence, you should first explain your reasoning towards solving the task, then the tools that you want to use.
Then in the 'Action:' sequence, you shold use one of your tools.
During each intermediate step, you can use 'Observation:' field to save whatever important information you will use as input for the next step.
'''

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])

prompt = '''Let’s think step by step.'''

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])

cot_answer = response['message']['content']

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content': f'''Here was your original answer:\n\n{cot_answer}\n\n
 Now reflect on whether it was correct or if it was the best approach. 
 If not, correct your reasoning and answer.'''}
])
print(response['message']['content'])

num_branches = 3

prompt = f'''
You will think of multiple reasoning paths (thought branches). For each path, write your reasoning and final answer.
After exploring {num_branches} different thoughts, pick the best final answer and explain why.
'''

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content': f"Task: {q} \n{prompt}"}
])
print(response['message']['content'])

class GoT:
 def __init__(self, question):
 self.question = question
 self.nodes = {} # node_id: text
 self.edges = [] # (from_node, to_node, relation)
 self.counter = 1

 def add_node(self, text):
 node_id = f"Thought{self.counter}"
 self.nodes[node_id] = text
 self.counter += 1
 return node_id

 def add_edge(self, from_node, to_node, relation):
 self.edges.append((from_node, to_node, relation))

 def show(self):
 print("\n--- Current Thoughts ---")
 for node_id, text in self.nodes.items():
 print(f"{node_id}: {text}\n")
 print("--- Connections ---")
 for f, t, r in self.edges:
 print(f"{f} --[{r}]--> {t}")
 print("\n")

 def expand_thought(self, node_id):
 prompt = f"""
 You are reasoning about the task: {self.question}
 Here is a previous thought node ({node_id}):\"\"\"{self.nodes[node_id]}\"\"\"
 Please provide a refinement, an alternative viewpoint, or a related thought that connects to this node.
 Label your new thought clearly, and explain its relation to the previous one.
 """
 response = ollama.chat(model=llm, messages=[{'role':'user', 'content':prompt}])
 return response['message']['content']

##開始構建圖
g = GoT(q)

## 獲取初始想法
response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content':q}
])
n1 = g.add_node(response['message']['content'])

##通過一些改進來擴展最初的想法
refinements = 1
for _ in range(refinements):
 expansion = g.expand_thought(n1)
 n_new = g.add_node(expansion)
 g.add_edge(n1, n_new, "expansion")
 g.show()

## 最終答案輸出
prompt = f'''
Here are the reasoning thoughts so far:
{chr(10).join([f"{k}: {v}" for k,v in g.nodes.items()])}
Based on these, select the best reasoning and final answer for the task: {q}
Explain your choice.
'''

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content':q}
])
print(response['message']['content'])

import re

def extract_python_code(text):
 match = re.search(r"```python(.*?)```", text, re.DOTALL)
 if match:
 return match.group(1).strip()
 return None

def sandbox_exec(code):
 ## 創建具有安全限制的最小沙盒
 allowed_builtins = {'abs', 'min', 'max', 'pow', 'round'}
 safe_globals = {k: __builtins__.__dict__[k] for k in allowed_builtins if k in __builtins__.__dict__}
 safe_locals = {}
 exec(code, safe_globals, safe_locals)
 return safe_locals.get('result', None)

prompt = '''
Write a short Python program that calculates the answer and assigns it to a variable named 'result'. 
Return only the code enclosed in triple backticks with 'python' (```python ... ```).
'''

response = ollama.chat(model=llm, messages=[
 {'role':'user', 'content': f"Task: {q} \n{prompt}"}
])
print(response['message']['content'])
sandbox_exec(code=extract_python_code(text=response['message']['content']))