### Project Setup and Dependency Installation

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/04_fundamental_ primitives/04_implementing_client/class_code/README.md

Provides instructions for setting up the project, including cloning the repository, installing dependencies using `uv sync` or `pip install -e .`, and running the Python examples.

```Bash
git clone <repository-url>
cd mcp_client
```

```Bash
uv sync
```

```Bash
pip install -e .
```

```Bash
python main.py
```

```Bash
python dump.py
```

```Bash
python client.py
```

--------------------------------

### Install and Launch Jupyter Notebook

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/other_material/01_prototype_to_production/00_prototyping/00_jupyter_notebooks/readme.md

Instructions for installing Jupyter Notebook using pip and launching the application from the command line. This is essential for getting started with the Jupyter environment.

```bash
pip install notebook
```

```bash
jupyter notebook
```

--------------------------------

### Project Setup and Execution

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/00_fun_fact_city/fun_fact_city/README.md

Commands for cloning the repository, navigating to the project directory, installing dependencies using uv, and running the LangGraph workflow.

```Bash
git clone https://github.com/panaverisity/learn-agentic-ai.git
cd /learn-agentic-ai/12a_langgraph_functional_api/00_fun_fact_city/fun_fact_city
# Rename .env.example to .env and add GOOGLE_API_KEY
# Optionally setup LangChain Variables for tracing in langsmith
uv sync

# To run the workflow:
uv run invoke
# or
uv run stream
```

--------------------------------

### Install Langchain Community

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Installs the Langchain Community library, which may contain additional utilities or integrations.

```python
!pip install -qU langchain_community
```

--------------------------------

### Install LangGraph CLI and Start Local Server

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/10a_deployment/README.md

Installs the LangGraph command-line interface and starts the local LangGraph server. This setup allows for local testing and interaction with deployed agentic applications before cloud deployment.

```bash
uv pip install langgraph-cli

langgraph up
```

--------------------------------

### Install Packages

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/chatbot/docs/00_quickstart_part1_to_part7.ipynb

Installs the required packages for LangGraph development using pip.

```python
%%capture --no-stderr
%pip install -U langgraph langsmith langchain_google_genai
```

--------------------------------

### Basic Graph Construction Example

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/chatbot/docs/00_quickstart_part1_to_part7.ipynb

An example demonstrating the creation of a simple LangGraph with a single node and setting entry/finish points.

```python
from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph

class State(TypedDict):
    messages: Annotated[list, add_messages]

builder = StateGraph(State)
builder.add_node("chatbot", lambda state: {"messages": [("assistant", "Hello")]})
builder.set_entry_point("chatbot")
builder.set_finish_point("chatbot")
graph = builder.compile()
```

--------------------------------

### Example Usage and Configuration

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/chatbot/docs/00_quickstart_part1_to_part7.ipynb

Demonstrates how to initiate the graph execution with a user input and configuration object, simulating a request for expert assistance.

```python
user_input = "I need some expert guidance for building this AI agent. Could you request assistance for me?"
config = {"configurable": {"thread_id": "1"}}
```

--------------------------------

### Install Langchain

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Installs the Langchain library using pip, a prerequisite for using Langchain components.

```python
!pip install -qU langchain
```

--------------------------------

### Initialize Project Directory

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/04_fundamental_ primitives/01_hello_mcp_server/readme.md

Sets up a new project directory named 'hello-mcp' and navigates into it using the 'uv' package manager.

```bash
uv init hello-mcp
cd hello-mcp
```

--------------------------------

### Install AutoGen

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07a_autogen_microsoft/03_tool_calling/readme.md

Installs the AutoGen library using pip. This is the first step to begin using AutoGen for building LLM applications.

```shell
pip install pyautogen
```

--------------------------------

### Verify UV Installation

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/01_intro_fastapi/readme.md

Checks if UV has been installed correctly by displaying its version. This command confirms that UV is accessible in your system's PATH.

```bash
uv --version
```

```bash
uv version
```

--------------------------------

### Project Initialization and Environment Setup

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/02_agent_native_cloud_setup/02_hello_containers/readme.md

Commands to initialize a new project using uv, create a virtual environment, and activate it on different operating systems. It also includes installing FastAPI with standard dependencies.

```bash
uv init daca_agent
cd daca_agent
```

```bash
# On macOS/Linux:
uv venv
source .venv/bin/activate
```

```bash
# On Windows:
uv venv
.venv\Scripts\activate
```

```bash
uv add "fastapi[standard]"
```

--------------------------------

### Install UV on Windows

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/01_intro_fastapi/readme.md

Installs the UV Python dependency manager using pip or PowerShell. UV streamlines dependency management for Python projects.

```powershell
pip install uv
```

```powershell
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Setup Project

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/02_a2a/a2a_modules/11_authentication/README.md

Command to navigate into the project directory and synchronize dependencies using UV. This is the initial setup step for the authentication module.

```bash
cd 11_authentication
uv sync
```

--------------------------------

### Start MCP Server

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/05_capabilities_and_transport/10_resumption/postman/POSTMAN_README.md

Command to start the example server for MCP resumption testing. The server includes a 6-second delay for simulating long-running tasks.

```bash
uv run server.py
```

--------------------------------

### Start the Server

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/05_capabilities_and_transport/08_completions/mcp_completions_server/README.md

Starts the MCP completions server using the 'uv' command-line tool. The server will be accessible at http://localhost:8000.

```bash
uv run server.py
```

--------------------------------

### Install UV on macOS/Linux

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/01_intro_fastapi/readme.md

Installs the UV Python dependency manager using pip or a shell script. UV is a fast and modern alternative to pip and virtualenv.

```bash
pip install uv
```

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Local Setup: Environment File

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/AGENT_PROTOTYPES/appointment-agent/README.md

Copies the example environment file to be used for local configuration. Users must update this file with their specific API keys and settings.

```bash
cp .env.example .env
```

--------------------------------

### Basic Agent Setup and Chat

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07a_autogen_microsoft/03_tool_calling/readme.md

Demonstrates the fundamental setup of two agents: a UserProxyAgent and an AssistantAgent. It shows how to initiate a chat between them to solve a problem, like writing a Python script.

```python
import autogen

config_list = [
    {
        "model": "gpt-4",
        "api_key": "YOUR_API_KEY",
    }
]

llm_config = {
    "config_list": config_list,
    "temperature": 0
}

# Create a UserProxyAgent instance
user_proxy = autogen.UserProxyAgent(
    name="UserProxy",
    system_message="A human admin who will interact with the assistant.",
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,  # Set to True if you want to use Docker
    },
)

# Create an AssistantAgent instance
assistant = autogen.AssistantAgent(
    name="Assistant",
    llm_config=llm_config,
    system_message="You are a helpful AI assistant.",
)

# Initiate a chat
user_proxy.initiate_chat(
    assistant,
    message="Write a python script that prints hello world.",
)

```

--------------------------------

### Full LangGraph Chatbot Setup

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/chatbot/docs/00_quickstart_part1_to_part7.ipynb

The complete code for setting up a basic LangGraph chatbot, including state definition, LLM integration, node creation, and graph compilation.

```python
from typing import Annotated

from langchain_anthropic import ChatAnthropic
from typing_extensions import TypedDict

from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages


class State(TypedDict):
    messages: Annotated[list, add_messages]


graph_builder = StateGraph(State)


llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")


def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages'])]}


# The first argument is the unique node name
# The second argument is the function or object that will be called whenever
# the node is used.
graph_builder.add_node("chatbot", chatbot)
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")
graph = graph_builder.compile()
```

--------------------------------

### Install Gemini API Python SDK

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Installs the necessary Python packages for the Gemini API (`google-generativeai`) and its integration with Langchain (`langchain-google-genai`). The `-q` flag suppresses output, and `-U` ensures the latest version is installed.

```python
!pip install -q -U google-generativeai
!pip install -qU langchain-google-genai
```

--------------------------------

### Running the MQTT Client Demo

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/extra/10_MQTT/readme.md

Instructions for setting up and running the MQTT client demonstration script. This includes saving the file, installing dependencies, and executing it from the terminal.

```APIDOC
1. Save the code as `17_MQTT/mqtt_combined_client.py`.
2. Ensure an MQTT broker is accessible (e.g., `test.mosquitto.org` or a local Mosquitto instance).
3. Install the `paho-mqtt` library: `pip install paho-mqtt` (or `uv pip install paho-mqtt`).
4. Run from your terminal: `python 17_MQTT/mqtt_combined_client.py`

Observe client activity by connecting an MQTT exploration tool (like MQTT Explorer) to the same broker and subscribing to `daca/agentic-ai/demo/#`.
```

--------------------------------

### ConversationChain Setup

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Sets up a Langchain ConversationChain with a Gemini LLM and ConversationBufferMemory to manage chat history.

```python
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
chat = ConversationChain(llm=llm, memory=memory)

response = chat.run("Hello, how can I assist you today?")
print(response)
```

--------------------------------

### Project Setup and Service Execution Commands

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/backup/02_microservices_with_fastapi/readme.md

Provides bash commands for setting up Python virtual environments, installing dependencies, and running the FastAPI microservices.

```bash
# Setup Chat Service
cd chat_service
uv sync
source .venv/bin/activate

# Setup Agent Memory Service
uv init agent_memory_service
cd agent_memory_service
uv venv
source .venv/bin/activate
uv add "fastapi[standard]" pytest pytest-asyncio
cd ..

# Run Agent Memory Service (port 8001)
cd agent_memory_service
uv run uvicorn main:app --host 0.0.0.0 --port 8001 --reload

# Run Chat Service (port 8000) in a separate terminal
cd chat_service
uv run uvicorn main:app --host 0.0.0.0 --port 8000 --reload
```

--------------------------------

### Download Example Image

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Downloads a sample image file for use in multimodal prompts using curl.

```python
!curl -o image.jpg https://t0.gstatic.com/licensed-image?q=tbn:ANd9GcQ_Kevbk21QBRy-PgB4kQpS79brbmmEG7m3VOTShAn4PecDU5H5UxrJxE3Dw1JiaG17V88QIol19-3TM2wCHw
```

--------------------------------

### Project Initialization and Setup

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/01_ai_agents_first/05_chainlit/helloworld/README.md

Commands to initialize a new project, navigate into it, create a virtual environment, and activate it. Includes instructions for setting up a .gitignore file to exclude the virtual environment directory.

```shell
uv init helloworld
cd helloworld
uv venv
```

```shell
# On Mac:
source .venv/bin/activate
```

```gitignore
.venv
```

--------------------------------

### Installing and Using tmux for Persistent Sessions

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/other_material/01_prototype_to_production/00_prototyping/01_google_colab/terminal.md

Explains how to install the 'tmux' package and start a 'tmux' session within Colab. 'tmux' allows you to maintain terminal sessions even if the notebook connection is interrupted.

```shell
!apt-get install tmux
```

```bash
!tmux
```

--------------------------------

### Project Initialization and Setup

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/10_advanced_agentic_ui/01_chainlite/helloworld/README.md

Commands to initialize a new project, navigate into it, create a virtual environment, and activate it. Includes instructions for setting up a .gitignore file to exclude the virtual environment directory.

```shell
uv init helloworld
cd helloworld
uv venv
```

```shell
# On Mac:
source .venv/bin/activate
```

```gitignore
.venv
```

--------------------------------

### Python Installation - macOS

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/01_ai_agents_first/01_uv/00_uv_installation/readme.md

Guide for installing Python on macOS using Homebrew. It includes the command to install Homebrew itself if it's not already present, followed by the Python installation command.

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

```bash
brew install python
```

```bash
python3 --version
```

--------------------------------

### Project Setup with uv and FastAPI

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/extra/11_SSE/readme.md

Commands to initialize a new Python project using 'uv' and add the 'fastapi[standard]' dependency for building web applications.

```shell
uv init python_sse
cd python_sse
uv add "fastapi[standard]"
```

--------------------------------

### Setup Dapr Environment with Tilt

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/05_agent_actors/01_hello_actors/README.md

Installs the Dapr FastAPI extension using uv and starts the Tilt development environment. Essential for running Dapr applications locally.

```bash
uv add dapr-ext-fastapi
tilt up
```

--------------------------------

### Initialize Git Repository

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/06_daca_deployment_guide/02_Enterprise-Deployment-Kubernetes/02_GitOps_and_Registry/GitOps-Setup-with-ArgoCD.md

Initializes a new Git repository, adds all files, creates an initial commit, and sets up the remote origin. This prepares the local repository for pushing to a remote server.

```bash
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/your-org/your-repo.git
git push -u origin main
```

--------------------------------

### Local Setup: Clone Repository

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/AGENT_PROTOTYPES/appointment-agent/README.md

Standard Git command to clone the project repository. This is the first step in setting up the project locally.

```bash
git clone https://github.com/...
cd ...
```

--------------------------------

### Chainlit Custom Welcome Message

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/00_openai_agents/18_deployment/02_chainlit_custom_config/README.md

Shows an example of a custom welcome message for Chainlit applications, written in Markdown, which is displayed to users upon starting a chat session.

```markdown
# Welcome to the Agentic AI Chatbot!

Ask me anything about AI, machine learning, or the latest research.
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/06_routing_pattern/assistant_selector/README.md

Provides commands to clone the repository, set up the environment by copying the .env.example file, and install project dependencies using uv.

```bash
git clone <repository-url>
cd assistant_selector
cp .env.example .env
# Add your API keys to .env
uv sync
```

--------------------------------

### Local Development Setup Commands

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/00_openai_agents/18_deployment/02_chainlit_custom_config/README.md

Provides essential bash commands for setting up a local Chainlit development environment, including virtual environment activation and dependency installation.

```bash
uv venv
source .venv/bin/activate  # On Unix/Mac
# OR
.venv\Scripts\activate  # On Windows
```

```bash
uv pip install -r requirements.txt
```

```bash
cp .env.example .env
```

```bash
chainlit run main.py -w
```

--------------------------------

### Install Pydantic for Dataclass Examples

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/00_openai_agents/00_python_syntax/README.md

Install the Pydantic library, which is required for specific examples demonstrating dataclasses with advanced validation and data transformation capabilities.

```bash
pip install pydantic
```

--------------------------------

### Setup LangGraph Studio Environment Variables

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/course-notebooks/README.md

Creates and populates '.env' files for LangGraph Studio, copying from '.env.example' and injecting necessary API keys (OpenAI, Tavily) for different modules.

```Shell
$ for i in {1..4}; do
  cp module-$i/studio/.env.example module-$i/studio/.env
  echo "OPENAI_API_KEY=\"$OPENAI_API_KEY\"" > module-$i/studio/.env
done
echo "TAVILY_API_KEY=\"$TAVILY_API_KEY\"" >> module-4/studio/.env
```

--------------------------------

### LangGraph Setup with Interrupt

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langgraph/chatbot/docs/00_quickstart_part1_to_part7.ipynb

Provides a complete example of setting up a LangGraph with a chatbot node, tool node, conditional edges, and compiling it with a memory checkpointer and the `interrupt_before` configuration to enable human-in-the-loop workflows.

```python
from typing import Annotated

from langchain_anthropic import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.messages import BaseMessage
from typing_extensions import TypedDict

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode, tools_condition


class State(TypedDict):
    messages: Annotated[list, add_messages]


graph_builder = StateGraph(State)


tool = TavilySearchResults(max_results=2)
tools = [tool]
llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
llm_with_tools = llm.bind_tools(tools)


def chatbot(state: State):
    return {"messages": [llm_with_tools.invoke(state["messages'])]}

graph_builder.add_node("chatbot", chatbot)

tool_node = ToolNode(tools=[tool])
graph_builder.add_node("tools", tool_node)

graph_builder.add_conditional_edges(
    "chatbot",
    tools_condition,
)
graph_builder.add_edge("tools", "chatbot")
graph_builder.set_entry_point("chatbot")

memory = MemorySaver()
graph = graph_builder.compile(
    checkpointer=memory,
    # This is new!
    interrupt_before=["tools"],
    # Note: can also interrupt __after__ actions, if desired.
    # interrupt_after=["tools"]
)
```

--------------------------------

### Project Setup and Environment Activation

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/08a_autogen_conversational_ai/00_single_agent/chatbot/README.md

These commands guide you through navigating to the project's chatbot directory, initializing a virtual environment using 'uv', and activating it on macOS systems. Proper environment setup is crucial for running the project dependencies.

```shell
cd chatbot

uv venv

# On Mac:
source .venv/bin/activate
```

--------------------------------

### Install uv Dependency Manager

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07b_crew_ai/04_crews_agents_tasks/01_crews/flows/project1/README.md

Installs the uv tool, a fast Python package installer and dependency manager, required for project setup.

```bash
pip install uv
```

--------------------------------

### Generate Content with Custom Safety Settings

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/07c_langgraph_functional_api/18_langchain_ecosystem/langchain/01_gemini_langchain_ai_studio/Gemini_with_Langchain_python.ipynb

Generates content from a model, overriding default safety settings to allow potentially harmful content. This example specifically blocks harassment.

```python
response = model.generate_content(
    "[Questionable prompt here]", safety_settings={"HARASSMENT": "block_none"}
)
response.text
```

--------------------------------

### Project Setup and Execution with Uvicorn

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/10_agent_to_agent/README.md

Commands for initializing a project, adding dependencies using Uvicorn, and running agent scripts. Covers project setup, dependency management, and starting various agent processes.

```bash
cd 10_agent_to_agent
uv init a2a_communication
cd a2a_communication
uv add a2a fastapi uvicorn httpx
```

```bash
# Terminal 1: Start coordinator agent
uv run python src/coordinator_agent.py

# Terminal 2: Start specialist agents
uv run python src/specialist_agents.py

# Terminal 3: Test communication
uv run python examples/basic_communication.py
```

```bash
# Test task delegation
uv run python examples/task_delegation.py

# Test streaming communication
uv run python examples/streaming_chat.py

# Test complex workflows
uv run python examples/multi_agent_workflow.py
```

--------------------------------

### Start MCP Pagination Server

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/03_ai_protocols/01_mcp/05_capabilities_and_transport/09_pagination/README.md

Command to start the Uvicorn server for the MCP pagination example. The server will run on http://127.0.0.1:8000.

```sh
cd mcp_pagination_server
uvicorn server:app --reload
```

--------------------------------

### Project Setup and Environment Activation

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/backup_recent/08a_autogen_conversational_ai/01_agent_team/chatbot/README.md

These commands guide you through navigating to the project's chatbot directory, initializing a virtual environment using 'uv', and activating it on macOS systems. Proper environment setup is crucial for running the project dependencies.

```shell
cd chatbot

uv venv

# On Mac:
source .venv/bin/activate
```

--------------------------------

### Install Dependencies

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/01_ai_agents_first/13_guardrails/readme.md

Installs the necessary Python packages for running the agent and guardrail example locally. Requires pip, notebook, agents, and pydantic.

```bash
pip install notebook agents pydantic
```

--------------------------------

### Project Setup Commands

Source: https://github.com/panaversity/learn-agentic-ai/blob/main/05_daca_agent_native_dev/05_agent_actors/07_daca_actor_runtime/01_actor_foundation/readme.md

Commands to set up the project structure, initialize a new Python package using 'uv', create a virtual environment, and add necessary dependencies like 'dapr', 'dapr-ext-fastapi', and 'fastapi'.

```bash
mkdir daca-ambient-agent
cd daca-ambient-agent

mkdir kubernetes
mkdir components

uv init --package ambient-actor
cd ambient-actor

uv venv
source .venv/bin/activate

uv add dapr
uv add dapr-ext-fastapi
uv add "fastapi[standard]"
```