On this tutorial, we discover 5 ranges of Agentic Architectures, from the best language mannequin calls to a completely autonomous code-generating system. This tutorial is designed to run seamlessly on Google Colab. Beginning with a primary “easy processor” that merely echoes the mannequin’s output, you’ll progressively construct routing logic, combine exterior instruments, orchestrate multi-step workflows, and in the end empower the mannequin to plan, validate, refine, and execute its personal Python code. All through every part, you’ll discover detailed explanations, self-contained demo features, and clear prompts that illustrate methods to stability human management and machine autonomy in real-world AI functions.
import os
import torch
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import re
import json
import time
import random
from IPython.show import clear_outputWe import core Python and third-party libraries, together with os and time for atmosphere and execution management, torch, together with Hugging Face’s transformers (pipeline, AutoTokenizer, AutoModelForCausalLM) for mannequin loading and inference. Additionally, we make the most of re and json for parsing LLM outputs, random seeds, and mock information, whereas clear_output maintains a tidy Colab interface.
MODEL_NAME = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
def get_model_and_tokenizer():
if not hasattr(get_model_and_tokenizer, "mannequin"):
print(f"Loading mannequin {MODEL_NAME}...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
mannequin = AutoModelForCausalLM.from_pretrained(
MODEL_NAME,
torch_dtype=torch.float16,
device_map="auto",
low_cpu_mem_usage=True
)
get_model_and_tokenizer.mannequin = mannequin
get_model_and_tokenizer.tokenizer = tokenizer
print("Mannequin loaded efficiently!")
return get_model_and_tokenizer.mannequin, get_model_and_tokenizer.tokenizerRight here, we outline MODEL_NAME to level on the TinyLlama 1.1B chat mannequin and implement a lazy‐loading helper get_model_and_tokenizer() that downloads and initializes the tokenizer and mannequin solely as soon as, caching them on first name to reduce overhead, after which returns the cached situations for all subsequent inference calls.
def get_model_and_tokenizer():
if not hasattr(get_model_and_tokenizer, "mannequin"):
print(f"Loading mannequin {MODEL_NAME}...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
mannequin = AutoModelForCausalLM.from_pretrained(
MODEL_NAME,
torch_dtype=torch.float16,
device_map="auto",
low_cpu_mem_usage=True
)
get_model_and_tokenizer.mannequin = mannequin
get_model_and_tokenizer.tokenizer = tokenizer
print("Mannequin loaded efficiently!")
return get_model_and_tokenizer.mannequin, get_model_and_tokenizer.tokenizerThis helper operate implements a lazy-loading sample for the TinyLlama mannequin and its tokenizer. On the primary name, it downloads and initializes each with half-precision and automated gadget placement, caches them as attributes on the operate object, and on subsequent calls, merely returns the already-loaded situations to keep away from redundant overhead.
def generate_text(immediate, max_length=512):
mannequin, tokenizer = get_model_and_tokenizer()
messages = [{"role": "user", "content": prompt}]
formatted_prompt = tokenizer.apply_chat_template(messages, tokenize=False)
inputs = tokenizer(formatted_prompt, return_tensors="pt").to(mannequin.gadget)
with torch.no_grad():
output = mannequin.generate(
**inputs,
max_new_tokens=max_length,
do_sample=True,
temperature=0.7,
top_p=0.9,
)
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
response = generated_text.break up("ASSISTANT: ")[-1].strip()
return responseThe generate_text operate wraps the TinyLlama inference workflow: it retrieves the cached mannequin and tokenizer, codecs the consumer immediate into the chat template, tokenizes and strikes inputs to the mannequin’s gadget, then samples a response with temperature and top-p settings. After technology, it decodes the output and extracts simply the assistant’s reply by splitting on the “ASSISTANT: ” marker.
Stage 1: Easy Processor
On the easiest stage, the code defines a simple textual content‐technology pipeline that treats the mannequin purely as a language processor. When the consumer offers a immediate, the `simple_processor` operate invokes the `generate_text` helper, which is constructed on the TinyLlama 1.1B chat mannequin, to supply a free-form response. It then shows that response immediately. Underneath the hood, `generate_text` ensures the mannequin and tokenizer are loaded simply as soon as by caching them contained in the `get_model_and_tokenizer` operate, codecs the immediate for the chat mannequin, runs technology with sampling parameters for variety, and extracts the assistant’s reply by splitting on the “ASSISTANT:” marker. This stage demonstrates essentially the most primary interplay sample: enter is obtained, output is generated, and program circulate stays totally beneath human management.
def simple_processor(immediate):
"""Stage 1: Easy Processor - Mannequin has no influence on program circulate"""
response = generate_text(immediate)
return response
def demo_level1():
print("n" + "="*50)
print("LEVEL 1: SIMPLE PROCESSOR DEMO")
print("="*50)
print("At this stage, the AI has no management over program circulate.")
print("It merely takes enter and produces output.n")
user_input = enter("Enter your query or immediate: ") or "Write a brief poem about synthetic intelligence."
print("nProcessing your request...n")
output = simple_processor(user_input)
print("OUTPUT:")
print("-"*50)
print(output)
print("-"*50)The simple_processor operate embodies the Easy Processor of our agent hierarchy by treating the mannequin purely as a textual content generator; it accepts a user-provided immediate and delegates to generate_text. It returns regardless of the mannequin produces with none branching or determination logic. The accompanying demo_level1 routine offers a minimal interactive loop, printing a transparent header, soliciting consumer enter (with a smart default), invoking simple_processor, after which displaying the uncooked output, showcasing essentially the most primary prompt-to-response workflow through which the AI exerts no affect over this system’s circulate.
Stage 2: Router
The second stage introduces conditional routing based mostly on the mannequin’s classification of the consumer’s question. The `router_agent` operate first asks the mannequin to categorise a question into “technical,” “artistic,” or “factual,” then normalizes the mannequin’s response into a type of classes. Relying on which class is detected, the question is dispatched to a specialised handler, both `handle_technical_query`, `handle_creative_query`, or `handle_factual_query`, every of which wraps the consumer’s question in a system-style immediate tailor-made to the chosen tone and goal. This routing mechanism offers the mannequin with partial management over program circulate, enabling it to information the following interplay path whereas nonetheless counting on human-defined handlers to generate the ultimate output.
def router_agent(user_query):
"""Stage 2: Router - Mannequin determines primary program circulate"""
category_prompt = f"""Classify the next question into certainly one of these classes:
'technical', 'artistic', or 'factual'.
Question: {user_query}
Return ONLY the class identify and nothing else."""
category_response = generate_text(category_prompt)
class = category_response.decrease()
if "technical" in class:
class = "technical"
elif "artistic" in class:
class = "artistic"
else:
class = "factual"
print(f"Question categorized as: {class}")
if class == "technical":
return handle_technical_query(user_query)
elif class == "artistic":
return handle_creative_query(user_query)
else:
return handle_factual_query(user_query)
def handle_technical_query(question):
system_prompt = f"""You're a technical assistant. Present detailed technical explanations.
Person question: {question}"""
response = generate_text(system_prompt)
return f"[Technical Response]n{response}"
def handle_creative_query(question):
system_prompt = f"""You're a artistic assistant. Be imaginative and galvanizing.
Person question: {question}"""
response = generate_text(system_prompt)
return f"[Creative Response]n{response}"
def handle_factual_query(question):
system_prompt = f"""You're a factual assistant. Present correct info concisely.
Person question: {question}"""
response = generate_text(system_prompt)
return f"[Factual Response]n{response}"
def demo_level2():
print("n" + "="*50)
print("LEVEL 2: ROUTER DEMO")
print("="*50)
print("At this stage, the AI determines primary program circulate.")
print("It decides which processing path to take.n")
user_query = enter("Enter your query or immediate: ") or "How do neural networks work?"
print("nProcessing your request...n")
consequence = router_agent(user_query)
print("OUTPUT:")
print("-"*50)
print(consequence)
print("-"*50)The router_agent operate implements Router conduct by first asking the mannequin to categorise the consumer’s question as “technical,” “artistic,” or “factual,” then normalizing that classification and dispatching the question to the corresponding handler (handle_technical_query, handle_creative_query, or handle_factual_query), every of which wraps the unique question in an applicable system‐model immediate earlier than calling generate_text. The demo_level2 routine offers a transparent CLI-style interface, printing headers, accepting enter (with a default), invoking router_agent, and displaying the categorized response, showcasing how the mannequin can take primary management over program circulate by selecting which processing path to observe.
Stage 3: Instrument Calling
On the third stage, the code empowers the mannequin to resolve which of a number of exterior instruments to invoke by embedding a JSON-based operate choice protocol into the immediate. The `tool_calling_agent` presents the consumer’s query alongside a menu of potential instruments, together with climate lookup, net search simulation, present date and time retrieval, or direct response, and instructs the mannequin to reply with a legitimate JSON message specifying the chosen instrument and its parameters. A regex then extracts the primary JSON object from the mannequin’s output, and the code safely falls again to a direct response if parsing fails. As soon as the instrument and arguments are recognized, the corresponding Python operate is executed, its result’s captured, and a last mannequin name integrates that consequence right into a coherent reply. This sample bridges LLM reasoning with concrete code execution by letting the mannequin orchestrate which APIs or utilities to name.
def tool_calling_agent(user_query):
"""Stage 3: Instrument Calling - Mannequin determines how features are executed"""
tool_selection_prompt = f"""Based mostly on the consumer question, choose essentially the most applicable instrument from the next record:
1. get_weather: Get the present climate for a location
2. search_information: Seek for particular info on a subject
3. get_date_time: Get present date and time
4. direct_response: Present a direct response with out utilizing instruments
USER QUERY: {user_query}
INSTRUCTIONS:
- Return your response in legitimate JSON format
- Embrace the instrument identify and any required parameters
- For get_weather, embody location parameter
- For search_information, embody question and depth parameter (primary or detailed)
- For get_date_time, embody timezone parameter (elective)
- For direct_response, no parameters wanted
Instance output format: {{"instrument": "get_weather", "parameters": {{"location": "New York"}}}}"""
tool_selection_response = generate_text(tool_selection_prompt)
strive:
json_match = re.search(r'({.*})', tool_selection_response, re.DOTALL)
if json_match:
tool_selection = json.hundreds(json_match.group(1))
else:
print("Couldn't parse instrument choice. Defaulting to direct response.")
tool_selection = {"instrument": "direct_response", "parameters": {}}
besides json.JSONDecodeError:
print("Invalid JSON in instrument choice. Defaulting to direct response.")
tool_selection = {"instrument": "direct_response", "parameters": {}}
tool_name = tool_selection.get("instrument", "direct_response")
parameters = tool_selection.get("parameters", {})
print(f"Chosen instrument: {tool_name}")
if tool_name == "get_weather":
location = parameters.get("location", "Unknown")
tool_result = get_weather(location)
elif tool_name == "search_information":
question = parameters.get("question", user_query)
depth = parameters.get("depth", "primary")
tool_result = search_information(question, depth)
elif tool_name == "get_date_time":
timezone = parameters.get("timezone", "UTC")
tool_result = get_date_time(timezone)
else:
return generate_text(f"Please present a useful response to: {user_query}")
final_prompt = f"""Person Question: {user_query}
Instrument Used: {tool_name}
Instrument End result: {json.dumps(tool_result)}
Based mostly on the consumer's question and the instrument consequence above, present a useful response."""
final_response = generate_text(final_prompt)
return final_response
def get_weather(location):
weather_conditions = ["Sunny", "Partly cloudy", "Overcast", "Light rain", "Heavy rain", "Thunderstorms", "Snowy", "Foggy"]
temperatures = {
"chilly": record(vary(-10, 10)),
"gentle": record(vary(10, 25)),
"scorching": record(vary(25, 40))
}
location_hash = sum(ord(c) for c in location)
condition_index = location_hash % len(weather_conditions)
season = ["winter", "spring", "summer", "fall"][location_hash % 4]
temp_range = temperatures["cold"] if season in ["winter", "fall"] else temperatures["hot"] if season == "summer time" else temperatures["mild"]
temperature = random.alternative(temp_range)
return {
"location": location,
"temperature": f"{temperature}°C",
"situations": weather_conditions[condition_index],
"humidity": f"{random.randint(30, 90)}%"
}
def search_information(question, depth="primary"):
mock_results = [
f"First result about {query}",
f"Second result discussing {query}",
f"Third result analyzing {query}"
]
if depth == "detailed":
mock_results.lengthen([
f"Fourth detailed analysis of {query}",
f"Fifth comprehensive overview of {query}",
f"Sixth academic paper on {query}"
])
return {
"question": question,
"outcomes": mock_results,
"depth": depth,
"sources": [f"source{i}.com" for i in range(1, len(mock_results) + 1)]
}
def get_date_time(timezone="UTC"):
current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
return {
"current_datetime": current_time,
"timezone": timezone
}
def demo_level3():
print("n" + "="*50)
print("LEVEL 3: TOOL CALLING DEMO")
print("="*50)
print("At this stage, the AI selects which instruments to make use of and with what parameters.")
print("It might probably course of the outcomes from instruments to create a last response.n")
user_query = enter("Enter your query or immediate: ") or "What is the climate like in San Francisco?"
print("nProcessing your request...n")
consequence = tool_calling_agent(user_query)
print("OUTPUT:")
print("-"*50)
print(consequence)
print("-"*50)Within the Stage 3 implementation, the tool_calling_agent operate prompts the mannequin to decide on amongst a predefined set of utilities, reminiscent of climate lookup, mock net search, or date/time retrieval, by returning a JSON object with the chosen instrument identify and its parameters. It then safely parses that JSON, invokes the corresponding Python operate to acquire structured information, and makes a follow-up mannequin name to combine the instrument’s output right into a coherent, user-facing response.
Stage 4: Multi-Step Agent
The fourth stage extends the tool-calling sample right into a full multi-step agent that manages its workflow and state. The `MultiStepAgent` class maintains an inner reminiscence of consumer inputs, instrument outputs, and agent actions. Every iteration generates a planning immediate that summarizes your complete reminiscence, asking the mannequin to decide on certainly one of a number of instruments, reminiscent of net search simulation, info extraction, textual content summarization, or report creation, or to conclude the duty with a last output. After executing the chosen instrument and appending its outcomes again to reminiscence, the method repeats till both the mannequin points a “full” motion or the utmost variety of steps is reached. Lastly, the agent collates the reminiscence right into a cohesive last response. This construction reveals how an LLM can orchestrate advanced, multi-stage processes whereas consulting exterior features and refining its plan based mostly on earlier outcomes.
class MultiStepAgent:
"""Stage 4: Multi-Step Agent - Mannequin controls iteration and program continuation"""
def __init__(self):
self.instruments = {
"search_web": self.search_web,
"extract_info": self.extract_info,
"summarize_text": self.summarize_text,
"create_report": self.create_report
}
self.reminiscence = []
self.max_steps = 5
def run(self, user_task):
self.reminiscence.append({"position": "consumer", "content material": user_task})
steps_taken = 0
whereas steps_taken The MultiStepAgent class maintains an evolving reminiscence of consumer inputs and power outputs, then repeatedly prompts the LLM to resolve its subsequent motion, whether or not to look the online, extract info, summarize textual content, create a report, or end, executing the chosen instrument and appending the consequence till the duty is full or a step restrict is reached. In doing so, it showcases a Stage 4 agent that orchestrates multi-step workflows by letting the mannequin management iteration and program continuation.
Stage 5: Absolutely Autonomous Agent
On the most superior stage, the `AutonomousAgent` class demonstrates a closed-loop system through which the mannequin not solely plans and executes but in addition generates, validates, refines, and runs new Python code. After the consumer job is recorded, the agent asks the mannequin to supply an in depth plan, then prompts it to generate self-contained resolution code, which is robotically cleaned of markdown formatting. A subsequent validation step queries the mannequin for any syntax or logic points; if points are discovered, the agent asks the mannequin to refine the code. The validated code is then wrapped with sandboxing utilities, reminiscent of secure printing, captured output buffers, and result-capture logic, and executed in a restricted native atmosphere. Lastly, the agent synthesizes an expert report explaining what was completed, the way it was completed, and the ultimate outcomes. This stage exemplifies a very autonomous AI system that may lengthen its capabilities by dynamic code creation and execution.
class AutonomousAgent:
"""Stage 5: Absolutely Autonomous Agent - Mannequin creates & executes new code"""
def __init__(self):
self.reminiscence = []
def run(self, user_task):
self.reminiscence.append({"position": "consumer", "content material": user_task})
print("🧠 Planning resolution strategy...")
planning_message = self.plan_solution(user_task)
self.reminiscence.append({"position": "assistant", "content material": planning_message})
print("💻 Producing resolution code...")
generated_code = self.generate_solution_code()
self.reminiscence.append({"position": "assistant", "content material": f"Generated code: ```pythonn{generated_code}n```"})
print("🔍 Validating code...")
validation_result = self.validate_code(generated_code)
if not validation_result["valid"]:
print("⚠️ Code validation discovered points - refining...")
refined_code = self.refine_code(generated_code, validation_result["issues"])
self.reminiscence.append({"position": "assistant", "content material": f"Refined code: ```pythonn{refined_code}n```"})
generated_code = refined_code
else:
print("✅ Code validation handed")
strive:
print("🚀 Executing resolution...")
execution_result = self.safe_execute_code(generated_code, user_task)
self.reminiscence.append({"position": "system", "content material": f"Execution consequence: {execution_result}"})
# Generate a last report
print("📝 Creating last report...")
final_report = self.create_final_report(execution_result)
return final_report
besides Exception as e:
return f"Error executing the answer: {str(e)}nnGenerated code was:n```pythonn{generated_code}n```"
def plan_solution(self, job):
immediate = f"""Job: {job}
You're an autonomous problem-solving agent. Create an in depth plan to resolve this job.
Embrace:
1. Breaking down the duty into subtasks
2. What algorithms or approaches you may use
3. What information buildings are wanted
4. Any exterior sources or libraries required
5. Anticipated challenges and methods to tackle them
Present a step-by-step plan.
"""
return generate_text(immediate)
def generate_solution_code(self):
context = "Job and planning info:n"
for merchandise in self.reminiscence:
if merchandise["role"] == "consumer":
context += f"USER TASK: {merchandise['content']}nn"
elif merchandise["role"] == "assistant":
context += f"PLANNING: {merchandise['content']}nn"
immediate = f"""{context}
Generate clear, environment friendly Python code that solves this job. Embrace feedback to clarify the code.
The code must be self-contained and capable of run inside a Python script or pocket book.
Solely embody the Python code itself with none markdown formatting.
"""
code = generate_text(immediate)
code = re.sub(r'^```pythonn|```$', '', code, flags=re.MULTILINE)
return code
def validate_code(self, code):
immediate = f"""Code to validate:
```python
{code}
```
Look at the code for the next points:
1. Syntax errors
2. Logic errors
3. Inefficient implementations
4. Safety considerations
5. Lacking error dealing with
6. Import statements for unavailable libraries
If the code has any points, describe them intimately. If the code seems good, state "No points discovered."
"""
validation_response = generate_text(immediate)
if "no points" in validation_response.decrease() or "code seems good" in validation_response.decrease():
return {"legitimate": True, "points": None}
else:
return {"legitimate": False, "points": validation_response}
def refine_code(self, original_code, points):
immediate = f"""Unique code:
```python
{original_code}
```
Points recognized:
{points}
Please present a corrected model of the code that addresses these points.
Solely embody the Python code itself with none markdown formatting.
"""
refined_code = generate_text(immediate)
refined_code = re.sub(r'^```pythonn|```$', '', refined_code, flags=re.MULTILINE)
return refined_code
def safe_execute_code(self, code, user_task):
safe_imports = """
# Customary library imports
import math
import random
import re
import time
import json
from datetime import datetime
# Outline a operate to seize printed output
captured_output = []
original_print = print
def safe_print(*args, **kwargs):
output = " ".be a part of(str(arg) for arg in args)
captured_output.append(output)
original_print(output)
print = safe_print
# Outline a consequence variable to retailer the ultimate output
consequence = None
# Perform to retailer the ultimate consequence
def store_result(worth):
world consequence
consequence = worth
return worth
"""
result_capture = """
# Retailer the ultimate consequence if not already completed
if 'consequence' not in locals() or result's None:
strive:
# Search for variables which may comprise the ultimate consequence
potential_results = [var for var in locals() if not var.startswith('_') and var not in
['math', 'random', 're', 'time', 'json', 'datetime',
'captured_output', 'original_print', 'safe_print',
'result', 'store_result']]
if potential_results:
# Use the final outlined variable because the consequence
store_result(locals()[potential_results[-1]])
besides:
go
"""
full_code = safe_imports + "n# Person code begins heren" + code + "nn" + result_capture
code_lines = code.break up('n')
first_lines = code_lines[:3]
print(f"nExecuting (first 3 strains):n{first_lines}")
local_env = {}
strive:
exec(full_code, {}, local_env)
return {
"output": local_env.get('captured_output', []),
"consequence": local_env.get('consequence', "No express consequence returned")
}
besides Exception as e:
return {"error": str(e)}
def create_final_report(self, execution_result):
if isinstance(execution_result.get('output'), record):
output_text = "n".be a part of(execution_result.get('output', []))
else:
output_text = str(execution_result.get('output', ''))
result_text = str(execution_result.get('consequence', ''))
error_text = execution_result.get('error', '')
context = "Job historical past:n"
for merchandise in self.reminiscence:
if merchandise["role"] == "consumer":
context += f"USER TASK: {merchandise['content']}nn"
immediate = f"""{context}
EXECUTION OUTPUT:
{output_text}
EXECUTION RESULT:
{result_text}
{f"ERROR: {error_text}" if error_text else ""}
Create a last report that explains the answer to the unique job. Embrace:
1. What was completed
2. The way it was completed
3. The ultimate outcomes
4. Any insights or conclusions drawn from the evaluation
Format the report in an expert, straightforward to learn method.
"""
return generate_text(immediate)
def demo_level5():
print("n" + "="*50)
print("LEVEL 5: FULLY AUTONOMOUS AGENT DEMO")
print("="*50)
print("At this stage, the AI generates and executes code to resolve advanced issues.")
print("It might probably create, validate, refine, and run customized code options.n")
user_task = enter("Enter an information evaluation or computational job: ") or "Analyze a dataset of numbers [10, 45, 65, 23, 76, 12, 89, 32, 50] and create visualizations of the distribution"
print("nProcessing your request... (this may increasingly take a minute or two)n")
agent = AutonomousAgent()
consequence = agent.run(user_task)
print("nFINAL REPORT:")
print("-"*50)
print(consequence)
print("-"*50)The AutonomousAgent class embodies the autonomy of a Absolutely Autonomous Agent by sustaining a working reminiscence of the consumer’s job and systematically orchestrating 5 core phases: planning, code technology, validation, secure execution, and reporting. When the run is initiated, the agent prompts the mannequin to generate an in depth plan for fixing the duty and shops this plan in reminiscence. Subsequent, it asks the mannequin to create self-contained Python code based mostly on that plan, strips away any markdown formatting, after which validates the code by querying the mannequin for syntax, logic, efficiency, and safety points. If validation uncovers issues, the agent instructs the mannequin to refine the code till it passes inspection. The finalized code is then wrapped in a sandboxed execution harness, full with captured output buffers and automated consequence extraction, and executed in an remoted native atmosphere. Lastly, the agent synthesizes a elegant, skilled report by feeding the execution outcomes again into the mannequin, producing a story that explains what was completed, the way it was completed, and what insights had been gained. The accompanying demo_level5 operate offers a simple, interactive loop that accepts a consumer job, runs the agent, and presents a complete last report.
Predominant Perform: All Above Steps
def predominant():
whereas True:
clear_output(wait=True)
print("n" + "="*50)
print("AI AGENT LEVELS DEMO")
print("="*50)
print("nThis pocket book demonstrates the 5 ranges of AI brokers:")
print("1. Easy Processor - Mannequin has no influence on program circulate")
print("2. Router - Mannequin determines primary program circulate")
print("3. Instrument Calling - Mannequin determines how features are executed")
print("4. Multi-Step Agent - Mannequin controls iteration and program continuation")
print("5. Absolutely Autonomous Agent - Mannequin creates & executes new code")
print("6. Give up")
alternative = enter("nSelect a stage to demo (1-6): ")
if alternative == "1":
demo_level1()
elif alternative == "2":
demo_level2()
elif alternative == "3":
demo_level3()
elif alternative == "4":
demo_level4()
elif alternative == "5":
demo_level5()
elif alternative == "6":
print("nThank you for exploring the AI Agent ranges!")
break
else:
print("nInvalid alternative. Please choose 1-6.")
enter("nPress Enter to return to the primary menu...")
if __name__ == "__main__":
predominant()
Lastly, the primary operate presents a easy, interactive menu loop that clears the Colab output for readability, shows all 5 agent ranges alongside a stop possibility, after which dispatches the consumer’s option to the corresponding demo operate earlier than ready for enter to return to the menu. This construction offers a cohesive, CLI-style interface enabling you to discover every agent stage in sequence with out handbook cell execution.
In conclusion, by working by these 5 ranges, we have now gained sensible perception into the ideas of agentic AI and the trade-offs between management, flexibility, and autonomy. We now have seen how a system can evolve from easy prompt-response conduct to advanced decision-making pipelines and even self-modifying code execution. Whether or not you purpose to prototype clever assistants, construct information pipelines, or experiment with rising AI capabilities, this development framework offers a roadmap for designing strong and scalable brokers.
Right here is the Colab Pocket book. Additionally, don’t neglect to observe us on Twitter and be a part of our Telegram Channel and LinkedIn Group. Don’t Neglect to hitch our 90k+ ML SubReddit.
Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is dedicated to harnessing the potential of Synthetic Intelligence for social good. His most up-to-date endeavor is the launch of an Synthetic Intelligence Media Platform, Marktechpost, which stands out for its in-depth protection of machine studying and deep studying information that’s each technically sound and simply comprehensible by a large viewers. The platform boasts of over 2 million month-to-month views, illustrating its recognition amongst audiences.
