On the coronary heart of each profitable AI Agent lies one important ability: prompting (or “immediate engineering”). It’s the technique of instructing LLMs to carry out duties by fastidiously designing the enter textual content.
Immediate engineering is the evolution of the inputs for the primary text-to-text NLP fashions (2018). On the time, builders usually centered extra on the modeling facet and have engineering. After the creation of huge GPT fashions (2022), all of us began utilizing principally pre-trained instruments, so the main focus has shifted on the enter formatting. Therefore, the “immediate engineering” self-discipline was born, and now (2025) it has matured into a mix of artwork and science, as NLP is blurring the road between code and immediate.
Several types of prompting methods create several types of Brokers. Every technique enhances a particular ability: logic, planning, reminiscence, accuracy, and Software integration. Let’s see all of them with a quite simple instance.
## setup
import ollama
llm = "qwen2.5"
## query
q = "What's 30 multiplied by 10?"Essential methods
1) “Common” prompting – simply ask a query and get an easy reply. Additionally known as “Zero-Shot” prompting particularly when the mannequin is given a activity with none prior examples of how you can clear up it. This primary method is designed for One-Step Brokers that execute the duty with out intermediate reasoning, particularly early fashions.
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content':q}
])
print(response['message']['content'])
2) ReAct (Reason+Act) – a mix of reasoning and motion. The mannequin not solely thinks via an issue but additionally takes motion based mostly on its reasoning. So, it’s extra interactive because the mannequin alternates between reasoning steps and actions, refining its method iteratively. Mainly, it’s a loop of thought-action-observation. Used for extra sophisticated duties, like looking the online and making selections based mostly on the findings, and usually designed for Multi-Step Brokers that carry out a collection of reasoning steps and actions to reach at a ultimate outcome. They’ll break down complicated duties into smaller, extra manageable elements that progressively construct upon each other.
Personally, I actually like ReAct Brokers as I discover them extra just like people as a result of they “f*ck round and discover out” identical to us.
immediate = '''
To resolve the duty, you could plan ahead to proceed in a collection of steps, in a cycle of 'Thought:', 'Motion:', and 'Commentary:' sequences.
At every step, within the 'Thought:' sequence, you need to first clarify your reasoning in direction of fixing the duty, then the instruments that you simply wish to use.
Then within the 'Motion:' sequence, you shold use one in every of your instruments.
Throughout every intermediate step, you need to use 'Commentary:' area to save lots of no matter necessary info you'll use as enter for the subsequent step.
'''
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])
3) Chain-of-Thought (CoT) – a reasoning sample that includes producing the method to succeed in a conclusion. The mannequin is pushed to “assume out loud” by explicitly laying out the logical steps that result in the ultimate reply. Mainly, it’s a plan with out suggestions. CoT is essentially the most used for superior duties, like fixing a math downside which may want step-by-step reasoning, and usually designed for Multi-Step Brokers.
immediate = '''Let’s assume step-by-step.'''
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])
CoT extensions
From the Chain-of-Method derived a number of different new prompting approaches.
4) Reflexion prompting that provides an iterative self-check or self-correction section on prime of the preliminary CoT reasoning, the place the mannequin opinions and critiques its personal outputs (recognizing errors, figuring out gaps, suggesting enhancements).
cot_answer = response['message']['content']
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content': f'''Here was your original answer:nn{cot_answer}nn
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'])
5) Tree-of-Thoughts (ToT) that generalizes CoT right into a tree, exploring a number of reasoning chains concurrently.
num_branches = 3
immediate = f'''
You'll consider a number of reasoning paths (thought branches). For every path, write your reasoning and ultimate reply.
After exploring {num_branches} totally different ideas, choose one of the best ultimate reply and clarify why.
'''
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content': f"Task: {q} n{prompt}"}
])
print(response['message']['content'])
6) Graph‑of‑Thoughts (GoT) that generalizes CoT right into a graph, contemplating additionally interconnected branches.
class GoT:
def __init__(self, query):
self.query = query
self.nodes = {} # node_id: textual content
self.edges = [] # (from_node, to_node, relation)
self.counter = 1
def add_node(self, textual content):
node_id = f"Thought{self.counter}"
self.nodes[node_id] = textual content
self.counter += 1
return node_id
def add_edge(self, from_node, to_node, relation):
self.edges.append((from_node, to_node, relation))
def present(self):
print("n--- Present Ideas ---")
for node_id, textual content in self.nodes.objects():
print(f"{node_id}: {textual content}n")
print("--- Connections ---")
for f, t, r in self.edges:
print(f"{f} --[{r}]--> {t}")
print("n")
def expand_thought(self, node_id):
immediate = f"""
You're reasoning concerning the activity: {self.query}
Here's a earlier thought node ({node_id}):"""{self.nodes[node_id]}"""
Please present a refinement, an alternate viewpoint, or a associated thought that connects to this node.
Label your new thought clearly, and clarify its relation to the earlier one.
"""
response = ollama.chat(mannequin=llm, messages=[{'role':'user', 'content':prompt}])
return response['message']['content']
## Begin Graph
g = GoT(q)
## Get preliminary thought
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content':q}
])
n1 = g.add_node(response['message']['content'])
## Broaden preliminary thought with some refinements
refinements = 1
for _ in vary(refinements):
growth = g.expand_thought(n1)
n_new = g.add_node(growth)
g.add_edge(n1, n_new, "growth")
g.present()
## Closing Reply
immediate = f'''
Listed here are the reasoning ideas to date:
{chr(10).be part of([f"{k}: {v}" for k,v in g.nodes.items()])}
Based mostly on these, choose one of the best reasoning and ultimate reply for the duty: {q}
Clarify your selection.
'''
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content':q}
])
print(response['message']['content'])
7) Program‑of‑Thoughts (PoT) that makes a speciality of programming, the place the reasoning occurs through executable code snippets.
import re
def extract_python_code(textual content):
match = re.search(r"```python(.*?)```", textual content, re.DOTALL)
if match:
return match.group(1).strip()
return None
def sandbox_exec(code):
## Create a minimal sandbox with security limitation
allowed_builtins = {'abs', 'min', 'max', 'pow', 'spherical'}
safe_globals = {ok: __builtins__.__dict__[k] for ok in allowed_builtins if ok in __builtins__.__dict__}
safe_locals = {}
exec(code, safe_globals, safe_locals)
return safe_locals.get('outcome', None)
immediate = '''
Write a brief Python program that calculates the reply and assigns it to a variable named 'outcome'.
Return solely the code enclosed in triple backticks with 'python' (```python ... ```).
'''
response = ollama.chat(mannequin=llm, messages=[
{'role':'user', 'content': f"Task: {q} n{prompt}"}
])
print(response['message']['content'])
sandbox_exec(code=extract_python_code(textual content=response['message']['content']))
Conclusion
This text has been a tutorial to recap all the foremost prompting methods for AI Brokers. There’s no single “finest” prompting method because it relies upon closely on the duty and the complexity of the reasoning wanted.
For instance, easy duties, like summarization and translation, are easiy carried out with a Zero-Shot/Common prompting, whereas CoT works effectively for math and logic duties. However, Brokers with Instruments are usually created with ReAct mode. Furthermore, Reflexion is most applicable when studying from errors or iterations improves outcomes, like gaming.
When it comes to versatility for complicated duties, PoT is the true winner as a result of it’s solely based mostly on code technology and execution. In truth, PoT Brokers are getting nearer to exchange people in a number of workplace taks.
I imagine that, within the close to future, prompting gained’t simply be about “what you say to the mannequin”, however about orchestrating an interactive loop between human intent, machine reasoning, and exterior motion.
Full code for this text: GitHub
I hope you loved it! Be happy to contact me for questions and suggestions or simply to share your attention-grabbing tasks.
👉 Let’s Connect 👈
(All photographs are by the creator except in any other case famous)
