Merge pull request #1740 from madeline-underwood/agentic

Agentic_Andy to review

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/_index.md

@@ -1,23 +1,19 @@
 ---
-title: Run an AI Agent Application with llama.cpp and llama-cpp-agent using KleidiAI on Arm servers.
-
-draft: true
-cascade:
-    draft: true
+title: Deploy an AI Agent on Arm with llama.cpp and llama-cpp-agent using KleidiAI
 
 minutes_to_complete: 45
 
-who_is_this_for: This is an introductory topic for software developers and ML engineers looking to run an AI Agent Application.
+who_is_this_for: This is an introductory topic for software developers and ML engineers looking to deploy an optimized AI agent application.
 
 learning_objectives:
-    - Set up llama-cpp-python optimised for Arm servers.
-    - Learn how to run optimized LLM models.
-    - Learn how to create custom functions for LLMs.
-    - Learn how to use AI Agents for applications.
+    - Set up llama-cpp-python optimized for Arm servers.
+    - Run optimized Large Language Models (LLMs).
+    - Create custom functions for LLMs.
+    - Deploy optimized AI agents for applications.
 
 prerequisites:
     - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider or an on-premise Arm server.
-    - Basic understanding of Python and Prompt Engineering
+    - Basic understanding of Python and Prompt Engineering.
     - Understanding of LLM fundamentals.
 
 author: Andrew Choi
@@ -30,6 +26,7 @@ armips:
 tools_software_languages:
     - Python
     - AWS Graviton
+    - AI
 operatingsystems:
     - Linux
 

content/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/agent-output.md

@@ -1,5 +1,5 @@
 ---
-title: Understand and test the AI Agent
+title: Explore and Test Your AI Agent
 weight: 5
 
 ### FIXED, DO NOT MODIFY
@@ -8,11 +8,13 @@ layout: learningpathall
 
 ## AI Agent Function Calls
 
-An AI agent, powered by a Large Language Model (LLM), decides which function to use by analyzing the prompt or input it receives, identifying the relevant intent or task, and then matching that intent to the most appropriate function from a pre-defined set of available functions based on its understanding of the language and context.
+An AI agent, powered by an LLM, selects the most appropriate function by analyzing the input, identifying the relevant intent, and matching it to predefined functions based on its understanding of the language and context.
 
-Lets look at how this is implemented in the python script `agent.py`.
+You will now walk through how this is implemented in the excerpt from a Python script called `agent.py`.
 
-- This code section of `agent.py` shown below creates an instance of the quantized `llama3.1 8B` model for more efficient inference on Arm-based systems.
+#### Initialize the Quantized Model 
+
+This code section of `agent.py` shown below creates an instance of the quantized `llama3.1 8B` model for more efficient inference on Arm-based systems:
 ```output
 llama_model = Llama(
     model_path="./models/dolphin-2.9.4-llama3.1-8b-Q4_0.gguf",
@@ -22,13 +24,17 @@ llama_model = Llama(
     n_threads_batch=64,
 )
 ```
+#### Define a Provider
 
-- Next, you define a provider that leverages the `llama.cpp` Python bindings.
+Now define a provider that leverages the `llama.cpp` Python bindings:
 ```output
 provider = LlamaCppPythonProvider(llama_model)
 ```
+#### Define Functions
+
+The LLM has access to certain tools or functions and can take a general user input and decide which functions to call. The function’s docstring guides the LLM on when and how to invoke it. 
 
-- The LLM has access to certain tools or functions and can take a general user input and decide which functions to call. The function’s docstring guides the LLM on when and how to invoke it. In `agent.py` three such tools or functions are defined `open_webpage`, `get_current_time` and `calculator` 
+In `agent.py` three such tools or functions are defined; `open_webpage`, `get_current_time`, and `calculator`: 
 
 ```output
 def open_webpage():
@@ -86,16 +92,19 @@ def calculator(
     else:
         raise ValueError("Unknown operation.")
 ```
+#### Create Output Settings to Enable Function Calls
 
-- `from_functions` creates an instance of `LlmStructuredOutputSettings` by passing in a list of callable Python functions. The LLM can then decide if and when to use these functions based on user queries.
+`from_functions` creates an instance of `LlmStructuredOutputSettings` by passing in a list of callable Python functions. The LLM can then decide if and when to use these functions based on user queries:
 
 ```output
 output_settings = LlmStructuredOutputSettings.from_functions(
     [get_current_time, open_webpage, calculator], allow_parallel_function_calling=True
 )
 
 ```
-- The user's prompt is then collected and processed through `LlamaCppAgent`. The agent decides whether to call any defined functions based on the request.
+#### Collect and Process User Input 
+
+The user's prompt is then collected and processed through `LlamaCppAgent`. The agent decides whether to call any defined functions based on the request:
 ```
 user = input("Please write your prompt here: ")
 
@@ -111,15 +120,15 @@ result = llama_cpp_agent.get_chat_response(
 )
 ```
 
-## Test the AI Agent
+## Test and Run the AI Agent
 
-You are now ready to test and execute the AI Agent python script. Start the application:
+You're now ready to test and run the AI agent Python script. Start the application:
 
 ```bash
 python3 agent.py
 ```
 
-You will see lots of interesting statistics being printed from `llama.cpp` about the model and the system, followed by the prompt as shown:
+You will see lots of interesting statistics being printed from `llama.cpp` about the model and the system, followed by the prompt for input, as shown:
 
 ```output
 llama_kv_cache_init:        CPU KV buffer size =  1252.00 MiB
@@ -142,9 +151,11 @@ Please write your prompt here:
 
 ## Test the AI agent
 
-When you are presented with "Please write your prompt here:" test it with an input prompt. Enter "What is the current time?"
+When you are presented with `Please write your prompt here:` test it with an input prompt. 
+
+Enter `What is the current time?`
 
-- As part of the prompt, a list of executable functions is sent to the LLM, allowing the agent to select the appropriate function:
+As part of the prompt, a list of executable functions is sent to the LLM, allowing the agent to select the appropriate function:
 
 ```output
 Read and follow the instructions below:
@@ -181,7 +192,7 @@ To call a function, respond with a JSON object (to call one function) or a list
 - "arguments": Put the arguments to pass to the function here.
 ```
 
-The AI Agent then decides to invoke the appropriate function and return the result as shown:
+The AI agent then decides to invoke the appropriate function and returns the result as shown:
 
 ```output
 [
@@ -197,9 +208,9 @@ Response from AI Agent:
 ----------------------------------------------------------------
 ```
 
-You have now tested when you enter, "What is the current time?", the AI Agent will choose to call the `get_current_time()` function, and return a result in **H:MM AM/PM** format.
+You have now tested the `What is the current time?` question. The AI agent evaluates the query and calls the `get_current_time()` function, and returns a result in **H:MM AM/PM** format.
 
-You have successfully run an AI agent. You can ask different questions to trigger and execute other functions. You can extend your AI agent by defining custom functions so it can handle specific tasks. 
+You have successfully run and tested your AI agent. Experiment with different prompts or define custom functions to expand your AI agent's capabilities. 
 
 
 

content/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/ai-agent-backend.md

@@ -7,7 +7,7 @@ layout: learningpathall
 ---
 
 ## Python Script for executing an AI Agent application
-With `llama.cpp` built and the Llama3.1 8B model downloaded, you are now ready to create a Python script to execute an AI Agent Application:
+With `llama.cpp` built and the Llama3.1 8B model downloaded, you are now ready to create a Python script to execute an AI agent application:
 
 Create a Python file named `agent.py` with the content shown below:
 ```bash
@@ -19,7 +19,6 @@ from llama_cpp_agent.chat_history.messages import Roles
 from llama_cpp_agent.llm_output_settings import LlmStructuredOutputSettings
 from llama_cpp_agent import LlamaCppFunctionTool
 from llama_cpp_agent import FunctionCallingAgent
-from llama_cpp_agent import MessagesFormatterType
 from llama_cpp_agent import LlamaCppAgent
 from llama_cpp_agent.providers import LlamaCppPythonProvider
 from llama_cpp import Llama
@@ -156,5 +155,5 @@ def run_web_search_agent():
 if __name__ == '__main__':
     run_web_search_agent()
 ```
-In the next section, you will inspect this script to understand how the LLM is configured and used to execute Agent tasks using this script. You will then proceed to executing and testing the AI Agent.
+In the next section, you will inspect this script to understand how the LLM is configured and used to execute agent tasks. You will then proceed to executing and testing the AI agent.
 

content/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/ai-agent.md

@@ -8,39 +8,41 @@ layout: learningpathall
 
 ## Overview of AI Agents
 
-An AI Agent is best understood as an integrated system that goes beyond standard text generation by equipping Large Language Models (LLMs) with tools and domain knowledge. Here’s a closer look at the underlying elements:
+An AI agent is an integrated system that extends beyond basic text generation by augmenting Large Language Models (LLMs) with tools and domain knowledge. 
 
-- **System**: Each AI Agent functions as an interconnected ecosystem of components.  
-  - **Environment**: The domain in which the AI Agent operates. For instance, in a system that books travel itineraries, the relevant environment might include airline reservation systems and hotel booking tools.  
-  - **Sensors**: Methods the AI Agent uses to observe its surroundings. For a travel agent, these could be APIs that inform the agent about seat availability on flights or room occupancy in hotels.  
-  - **Actuators**: Ways the AI Agent exerts influence within that environment. In the example of a travel agent, placing a booking or modifying an existing reservation serves as the agent’s “actuators.”  
+Here’s a closer look at the underlying elements:
 
-- **Large Language Models**: While the notion of agents is not new, LLMs bring powerful language comprehension and data-processing capabilities to agent setups.  
-- **Performing Actions**: Rather than just produce text, LLMs within an agent context interpret user instructions and interact with tools to achieve specific objectives.  
-- **Tools**: The agent’s available toolkit depends on the software environment and developer-defined boundaries. In the travel agent example, these tools might be limited to flight and hotel reservation APIs.  
-- **Knowledge**: Beyond immediate data sources, the agent can fetch additional details—perhaps from databases or web services—to enhance decision making.
+- **System**: Each AI agent functions as an interconnected ecosystem of components. Below is a list of key factors and components that affect system performance:   
+  - **Environment**: The domain in which the AI agent operates. For instance, in a system that books travel itineraries, this might include airline reservation systems and hotel booking tools.  
+  - **Sensors**: The methods the AI agent uses to observe its environment. For a travel agent, these might be APIs that inform the agent about seat availability on flights or room occupancy in hotels.  
+  - **Actuators**: Ways the AI agent exerts influence within the environment. In the example of a travel agent, placing a booking or modifying an existing reservation illustrates how actuators function to enact changes within the environment.  
+
+- **Large Language Models**: While agents have long existed, LLMs enhance these systems with powerful language comprehension and data-processing capabilities.  
+- **Action Execution**: Rather than just produce text, LLMs within an agent context interpret user instructions and interact with tools to achieve specific objectives.  
+- **Tools**: The agent’s available toolkit depends on the software environment and developer-defined boundaries. In the travel agent example in this Learning Path, these tools might be limited to flight and hotel reservation APIs.  
+- **Knowledge**: Beyond immediate data sources, the agent can fetch additional details - perhaps from databases or web services - for enhanced decision-making.
 
 
 
 ## Types of AI Agents
 
-AI Agents come in multiple forms. The table below provides an overview of some agent types and examples illustrating their roles in a travel booking system:
+AI agents come in multiple forms. The table below provides an overview of some agent types and examples of their roles in a travel booking system:
 
-| **Agent Category**       | **Key Characteristics**                                                             | **Example usage in a Travel system**                                                                                                                   |
+| **Agent Category**       | **Key Characteristics**                                                             | **Example Usage in a Travel Booking System**                                                                                                                   |
 |--------------------------|--------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
-| **Simple Reflex Agents** | Act directly based on set rules or conditions.                                      | Filters incoming messages and forwards travel-related emails to a service center.                                                       |
+| **Simple Reflex Agents** | Act directly based on predefined rules or conditions.                                      | Filters incoming messages and forwards travel-related emails to a service center.                                                       |
 | **Model-Based Agents**   | Maintain an internal representation of the world and update it based on new inputs.  | Monitors flight prices and flags dramatic fluctuations, guided by historical data.                                                      |
-| **Goal-Based Agents**    | Execute actions with the aim of meeting designated objectives.                       | Figures out the necessary route (flights, transfers) to get from your current location to your target destination.                       |
+| **Goal-Based Agents**    | Execute actions with the aim of meeting designated objectives.                       | Determines the necessary route (flights, transfers) to get from your current location to your target destination.                       |
 | **Utility-Based Agents** | Use scoring or numerical metrics to compare and select actions that fulfill a goal. | Balances cost versus convenience when determining which flights or hotels to book.                                                      |
 | **Learning Agents**      | Adapt over time by integrating lessons from previous feedback or experiences.        | Adjusts future booking suggestions based on traveler satisfaction surveys.                                                              |
 | **Hierarchical Agents**  | Split tasks into sub-tasks and delegate smaller pieces of work to subordinate agents.| Cancels a trip by breaking down the process into individual steps, such as canceling a flight, a hotel, and a car rental.               |
-| **Multi-Agent Systems**  | Involve multiple agents that may cooperate or compete to complete tasks.             | Cooperative: Different agents each manage flights, accommodations, and excursions. Competitive: Several agents vie for limited rooms.   |
+| **Multi-Agent Systems**  | Involve multiple agents that might cooperate or compete to complete tasks.             | Cooperative: Different agents each manage flights, accommodations, and excursions. Competitive: Several agents vie for limited rooms.   |
 
 
 ## Ideal Applications for AI Agents
 
-While the travel scenario illustrates different categories of AI Agents, there are broader circumstances where agents truly excel:
+AI agents come in multiple forms. They can be grouped into various categories and excel in a wide range of applications:
 
-- **Open-Ended Challenges**: Complex tasks with no predetermined procedure, requiring the agent to determine the necessary steps.  
-- **Procedural or Multi-Step Tasks**: Endeavors requiring numerous phases or tool integrations, allowing the agent to switch between resources.  
-- **Continual Improvement**: Contexts where feedback loops enable the agent to refine its behaviors for better outcomes in the future.
+- **Open-Ended Challenges**: Complex tasks with no predetermined procedure, requiring the agent to determine its own steps.  
+- **Procedural or Multi-Step Tasks**: Tasks involving multiple phases or tool integrations that enable the agent to switch between resources.  
+- **Continual Improvement**: Contexts where feedback loops enable the agent to refine its behavior for better outcomes.