# 1. Create a virtual environment
python -m venv agentic_env

# 2. Activate the virtual environment
# On macOS/Linux:
source agentic_env/bin/activate
# On Windows:
# .\agentic_env\Scripts\activate

# 3. Install core LangChain packages and a general LLM provider (e.g., OpenAI)
pip install langchain langchain-openai python-dotenv

# 4. For web search tool, install duckduckgo-search
pip install -U langchain-community duckduckgo-search

# 5. For LangGraph (later in the document)
pip install langgraph

# 6. For CrewAI (later in the document)
pip install crewai

import os
from dotenv import load_dotenv

load_dotenv() # This loads variables from .env into your environment
# openai_api_key = os.getenv("OPENAI_API_KEY") # You usually don't need to explicitly assign, LangChain will find it.

ollama pull llama3
# You can also pull other models like 'mistral', 'gemma', etc.

pip install langchain-community

from langchain_community.chat_models import ChatOllama

# Ensure 'llama3' is pulled and running in Ollama (ollama run llama3 in a separate terminal)
local_llm = ChatOllama(model="llama3", temperature=0)

# Test it
# print(local_llm.invoke("What is the capital of Canada?"))

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI # For OpenAI
# from langchain_community.chat_models import ChatOllama # For Ollama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Load environment variables from .env file (for OpenAI API key)
load_dotenv()

def run_basic_llm_interaction():
    print("--- Running Basic LLM Interaction ---")

    # 1. Initialize the LLM
    # Using OpenAI's GPT-3.5-turbo. Make sure OPENAI_API_KEY is set in .env.
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

    # --- To use a local Ollama model instead, uncomment the following line ---
    # Make sure Ollama is installed and 'llama3' is pulled (ollama pull llama3)
    # And run 'ollama run llama3' in a separate terminal before executing this script.
    # llm = ChatOllama(model="llama3", temperature=0)
    # -------------------------------------------------------------------------

    # 2. Define a simple prompt template
    # This guides the LLM on how to respond.
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a concise and helpful AI assistant."),
        ("user", "{input}")
    ])

    # 3. Define an output parser
    # Converts the LLM's raw output into a simple string.
    output_parser = StrOutputParser()

    # 4. Create a simple chain
    # Chains connect components: Prompt -> LLM -> Output Parser
    chain = prompt | llm | output_parser

    # 5. Invoke the chain with a user question
    question = "What is the capital of France?"
    print(f"\nUser Question: {question}")
    response = chain.invoke({"input": question})

    print(f"AI Response: {response}")

    # Another example
    question_two = "What is the primary benefit of using Python for data science?"
    print(f"\nUser Question: {question_two}")
    response_two = chain.invoke({"input": question_two})
    print(f"AI Response: {response_two}")

if __name__ == "__main__":
    run_basic_llm_interaction()

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun # Our web search tool
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub # To pull standard agent prompts
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# Load environment variables
load_dotenv()

def run_web_search_agent():
    print("--- Running Web Search Agent ---")

    # 1. Initialize the LLM (for reasoning and answering)
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    # llm = ChatOllama(model="llama3", temperature=0) # For Ollama

    # 2. Define the tools the agent can use
    # DuckDuckGoSearchRun is a simple, no-API-key-needed search tool.
    search_tool = DuckDuckGoSearchRun(name="duckduckgo_search")
    tools = [search_tool]

    # 3. Get the standard ReAct agent prompt from LangChain Hub
    # This prompt instructs the LLM on how to "Think", "Act", "Observe", and "Final Answer".
    prompt = hub.pull("hwchase17/react")

    # 4. Create the agent
    # `create_react_agent` is a factory function that sets up the LLM, tools, and prompt
    # to follow the ReAct (Reasoning and Acting) pattern.
    agent = create_react_agent(llm, tools, prompt)

    # 5. Create the Agent Executor
    # The AgentExecutor is the runtime that drives the agent's decision-making loop.
    # `verbose=True` shows the agent's internal thoughts and actions, which is crucial for understanding!
    # `handle_parsing_errors=True` allows the agent to try and correct its output if it makes a mistake.
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    # 6. Invoke the agent with questions
    print("\n--- Question 1: Current Event ---")
    question_1 = "What is the current capital of Australia?"
    print(f"User: {question_1}")
    response_1 = agent_executor.invoke({"input": question_1})
    print(f"\nAgent's Final Answer: {response_1['output']}")

    print("\n--- Question 2: General Knowledge (should not need tool) ---")
    question_2 = "What is the chemical symbol for water?"
    print(f"User: {question_2}")
    response_2 = agent_executor.invoke({"input": question_2})
    print(f"\nAgent's Final Answer: {response_2['output']}")

if __name__ == "__main__":
    run_web_search_agent()

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain.tools import tool # Decorator to easily create tools
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# Load environment variables
load_dotenv()

# 1. Define custom tools using the @tool decorator
@tool
def add(a: int, b: int) -> int:
    """Adds two integers together and returns their sum."""
    print(f"\n--- Tool Call: add({a}, {b}) ---")
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiplies two integers together and returns their product."""
    print(f"\n--- Tool Call: multiply({a}, {b}) ---")
    return a * b

def run_custom_calculator_agent():
    print("--- Running Custom Calculator Agent ---")

    # Initialize LLM
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    # llm = ChatOllama(model="llama3", temperature=0) # For Ollama

    # 2. Bundle the custom tools
    tools = [add, multiply]

    # 3. Get the ReAct prompt
    prompt = hub.pull("hwchase17/react")

    # 4. Create the agent
    agent = create_react_agent(llm, tools, prompt)

    # 5. Create the Agent Executor
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    # 6. Invoke the agent with mathematical questions
    print("\n--- Question 1: Simple Addition ---")
    question_1 = "What is 1500 plus 2345?"
    print(f"User: {question_1}")
    response_1 = agent_executor.invoke({"input": question_1})
    print(f"\nAgent's Final Answer: {response_1['output']}")

    print("\n--- Question 2: Multi-step calculation ---")
    question_2 = "Calculate (75 multiplied by 12) then add 50."
    print(f"User: {question_2}")
    response_2 = agent_executor.invoke({"input": question_2})
    print(f"\nAgent's Final Answer: {response_2['output']}")

    print("\n--- Question 3: Non-math question (should not use tool) ---")
    question_3 = "What color is the sky on a clear day?"
    print(f"User: {question_3}")
    response_3 = agent_executor.invoke({"input": question_3})
    print(f"\nAgent's Final Answer: {response_3['output']}")

if __name__ == "__main__":
    run_custom_calculator_agent()

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain.memory import ConversationBufferMemory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage

# Load environment variables
load_dotenv()

def run_conversational_agent_with_memory():
    print("--- Running Conversational Agent with Memory ---")

    # 1. Initialize the LLM
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    # llm = ChatOllama(model="llama3", temperature=0) # For Ollama

    # 2. Define tools (web search for current info)
    search_tool = DuckDuckGoSearchRun(name="duckduckgo_search")
    tools = [search_tool]

    # 3. Get a conversational ReAct agent prompt from LangChain Hub
    # This prompt is designed to handle chat history.
    prompt = hub.pull("hwchase17/react-chat-json") # A prompt variant suitable for chat history

    # 4. Create the agent
    # We use `create_react_agent` with our conversational prompt.
    agent = create_react_agent(llm, tools, prompt)

    # 5. Create the Agent Executor
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    # 6. Initialize ConversationBufferMemory
    # This memory stores raw conversational messages.
    # `memory_key="chat_history"` tells the prompt where to find the history.
    # `return_messages=True` ensures messages are returned as actual message objects.
    memory = ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )

    # 7. Wrap the agent executor with RunnableWithMessageHistory
    # This runnable manages the memory for different chat sessions.
    # It dynamically loads and saves chat history for a given 'session_id'.
    conversational_agent = RunnableWithMessageHistory(
        agent_executor,
        lambda session_id: memory, # This function provides the memory for a given session ID
        input_messages_key="input", # Key for current user input
        history_messages_key="chat_history" # Key where agent expects history in prompt
    )

    # 8. Engage in a conversation
    session_id = "user_session_abc123" # A unique ID for this conversation session

    print("\n--- Turn 1 ---")
    user_input_1 = "Hi, my name is Alex. What is the tallest building in the world currently?"
    print(f"User: {user_input_1}")
    response_1 = conversational_agent.invoke(
        {"input": user_input_1},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent's Final Answer: {response_1['output']}")

    print("\n--- Turn 2 (Testing memory and tool use) ---")
    user_input_2 = "Okay, and what was my name again? Also, what's the capital of Japan?"
    print(f"User: {user_input_2}")
    response_2 = conversational_agent.invoke(
        {"input": user_input_2},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent's Final Answer: {response_2['output']}")

    print("\n--- Turn 3 (Memory check, no tool needed) ---")
    user_input_3 = "Thanks! Could you remind me what the tallest building is?"
    print(f"User: {user_input_3}")
    response_3 = conversational_agent.invoke(
        {"input": user_input_3},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent's Final Answer: {response_3['output']}")


if __name__ == "__main__":
    run_conversational_agent_with_memory()

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import SystemMessage

# Load environment variables
load_dotenv()

def run_custom_prompt_agent():
    print("--- Running Custom Prompt Marketing Agent ---")

    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7) # Slightly higher temp for creativity
    # llm = ChatOllama(model="llama3", temperature=0.7) # For Ollama

    search_tool = DuckDuckGoSearchRun(name="web_search")
    tools = [search_tool]

    # 1. Define a CUSTOM Prompt Template
    # We combine a SystemMessage with the standard ReAct components.
    custom_system_message = SystemMessage(
        content=(
            "You are an expert Marketing Idea Generator. Your goal is to brainstorm innovative marketing campaigns."
            "Always use the 'web_search' tool to gather inspiration or current trends related to the product/service."
            "When providing a final answer, it MUST be formatted as a creative marketing campaign idea, including:"
            "1. Campaign Name\n2. Slogan\n3. Target Audience\n4. Key Concept (at least 3 sentences)"
            "Be creative and concise."
        )
    )

    # This combines our custom system message with the standard agent scratchpad and human input.
    # The `MessagesPlaceholder` for `agent_scratchpad` is where the ReAct loop unfolds.
    prompt = ChatPromptTemplate.from_messages([
        custom_system_message,
        ("user", "{input}"),
        MessagesPlaceholder("agent_scratchpad") # This is crucial for ReAct loop
    ])

    # 2. Create the agent with the custom prompt
    agent = create_react_agent(llm, tools, prompt)

    # 3. Create the Agent Executor
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    # 4. Invoke the agent
    print("\n--- Generating Marketing Idea ---")
    product_idea = "A new line of eco-friendly, compostable phone cases."
    print(f"User: Generate a marketing campaign for: {product_idea}")
    response = agent_executor.invoke({"input": f"Generate a marketing campaign for: {product_idea}"})
    print(f"\nAgent's Final Answer:\n{response['output']}")

if __name__ == "__main__":
    run_custom_prompt_agent()

import os
import asyncio
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain.tools import tool
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessage
from pydantic import BaseModel, Field # For structured tool inputs

# Load environment variables
load_dotenv()

# 1. Define a Pydantic model for structured tool input
class SendEmailInput(BaseModel):
    recipient_email: str = Field(description="The email address of the recipient.")
    subject: str = Field(description="The subject line of the email.")
    body_content: str = Field(description="The main content of the email.")

# 2. Define an ASYNCHRONOUS tool with Pydantic input
@tool("send_email_async", args_schema=SendEmailInput)
async def send_email_tool_async(
    recipient_email: str,
    subject: str,
    body_content: str
) -> str:
    """
    Sends a simulated email to a specified recipient with a given subject and body.
    This tool is asynchronous to simulate network latency.
    """
    print(f"\n--- Async Tool Call: send_email_tool_async ---")
    print(f"  Attempting to send email to: {recipient_email}")
    print(f"  Subject: {subject}")
    print(f"  Body (first 50 chars): {body_content[:50]}...")

    await asyncio.sleep(2) # Simulate network delay

    if "@example.com" in recipient_email:
        return f"Simulated email sent successfully to {recipient_email} with subject '{subject}'."
    else:
        # Simulate a validation error
        return f"Error: Invalid recipient email domain for {recipient_email}. Only @example.com allowed for simulation."

def run_advanced_custom_tools_agent():
    print("--- Running Agent with Advanced Custom Tools ---")

    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    # llm = ChatOllama(model="llama3", temperature=0) # For Ollama

    tools = [send_email_tool_async]

    # Custom prompt to guide the agent to use the email tool and extract parameters
    custom_system_message = SystemMessage(
        content=(
            "You are an email automation assistant. Your primary task is to send emails using the 'send_email_async' tool."
            "Carefully extract the recipient's email, subject, and body from the user's request."
            "If any information is missing, ask for clarification."
            "If the email sending fails, report the error to the user."
            "Always respond with a concise confirmation or error message."
        )
    )

    prompt = ChatPromptTemplate.from_messages([
        custom_system_message,
        ("user", "{input}"),
        MessagesPlaceholder("agent_scratchpad")
    ])

    agent = create_react_agent(llm, tools, prompt)

    # Note: For async agents, you typically use `ainvoke`
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    async def interact_with_agent():
        print("\n--- Interaction 1: Valid Email Request ---")
        user_input_1 = "Please send an email to alice@example.com. The subject should be 'Project Status Update'. The body content is 'Hi Alice, the project is on track for Q4. Best, Bob.'"
        print(f"User: {user_input_1}")
        response_1 = await agent_executor.ainvoke({"input": user_input_1})
        print(f"\nAgent's Final Answer: {response_1['output']}")

        print("\n--- Interaction 2: Invalid Email Domain ---")
        user_input_2 = "Can you send a quick note to charlie@bad-domain.net with subject 'Quick Chat' and body 'When are you free?'"
        print(f"User: {user_input_2}")
        response_2 = await agent_executor.ainvoke({"input": user_input_2})
        print(f"\nAgent's Final Answer: {response_2['output']}")

        print("\n--- Interaction 3: Missing Information ---")
        user_input_3 = "Send an email to sarah@example.com about a meeting."
        print(f"User: {user_input_3}")
        response_3 = await agent_executor.ainvoke({"input": user_input_3})
        print(f"\nAgent's Final Answer: {response_3['output']}")


    # Run the asynchronous interactions
    asyncio.run(interact_with_agent())

if __name__ == "__main__":
    run_advanced_custom_tools_agent()

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain.tools import tool
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessage

# Load environment variables
load_dotenv()

@tool
def process_data_entry(entry_id: str, value: int) -> str:
    """Processes a data entry with a specific ID and an integer value.
    Returns success message or error if value is negative."""
    print(f"\n--- Tool Call: process_data_entry({entry_id}, {value}) ---")
    if value < 0:
        return f"Error: Value for entry '{entry_id}' cannot be negative."
    return f"Successfully processed entry '{entry_id}' with value {value}."

def run_self_correction_agent():
    print("--- Running Self-Correction Agent ---")

    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    # llm = ChatOllama(model="llama3", temperature=0) # For Ollama

    tools = [process_data_entry]

    custom_system_message = SystemMessage(
        content=(
            "You are a data processing agent. Use the 'process_data_entry' tool to process user requests."
            "The 'value' parameter for the tool MUST be an integer."
            "If you make a mistake in calling the tool, analyze the error and try to correct it."
            "Always report the outcome to the user."
        )
    )

    prompt = ChatPromptTemplate.from_messages([
        custom_system_message,
        ("user", "{input}"),
        MessagesPlaceholder("agent_scratchpad")
    ])

    agent = create_react_agent(llm, tools, prompt)

    # Key for self-correction: handle_parsing_errors=True
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True # This enables the agent to try and recover
    )

    print("\n--- Interaction 1: Deliberate LLM Parsing Error (value as string) ---")
    user_input_1 = "Process data entry 'X123' with value 'ten'." # 'ten' is not an integer
    print(f"User: {user_input_1}")
    response_1 = agent_executor.invoke({"input": user_input_1})
    print(f"\nAgent's Final Answer: {response_1['output']}")

    print("\n--- Interaction 2: Valid Call ---")
    user_input_2 = "Process data entry 'Y456' with value 100."
    print(f"User: {user_input_2}")
    response_2 = agent_executor.invoke({"input": user_input_2})
    print(f"\nAgent's Final Answer: {response_2['output']}")

if __name__ == "__main__":
    run_self_correction_agent()

import os
from dotenv import load_dotenv
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.utils.function_calling import format_tool_to_openai_function

# Load environment variables
load_dotenv()

# --- 1. Define the Graph State ---
# This TypedDict defines the structure of the data that flows through our graph.
# `Annotated` with a lambda function provides a way to define how lists (like chat_history) are merged.
class AgentState(TypedDict):
    chat_history: Annotated[List[BaseMessage], lambda x, y: x + y] # Accumulates messages
    # user_input: str # Not strictly needed if input is always in chat_history

# --- 2. Initialize LLM and Tools ---
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# llm = ChatOllama(model="llama3", temperature=0) # For Ollama

search_tool = DuckDuckGoSearchRun(name="web_search")
tools = [search_tool]

# LangGraph with OpenAI's function calling models needs tools in a specific format
llm_with_tools = llm.bind_functions([format_tool_to_openai_function(t) for t in tools])

# --- 3. Define the Nodes for the Graph ---

def call_llm(state: AgentState):
    """Node that calls the LLM for decision-making or final answer."""
    messages = state["chat_history"]
    print(f"\n--- LLM Node: Input Messages ---")
    for msg in messages:
        print(f"  {type(msg).__name__}: {msg.content}")

    response = llm_with_tools.invoke(messages)
    return {"chat_history": [response]} # Add LLM's response to history

def call_tool(state: AgentState):
    """Node that executes a tool based on the LLM's decision."""
    last_message = state["chat_history"][-1]
    print(f"\n--- Tool Node: Last LLM Message ---")
    print(f"  {type(last_message).__name__}: {last_message.content}")

    if not last_message.tool_calls:
        raise ValueError("LLM did not specify a tool to call.")

    # Execute the first tool call suggested by the LLM
    tool_call = last_message.tool_calls[0]
    tool_name = tool_call["name"]
    tool_args = tool_call["args"]

    if tool_name == search_tool.name:
        print(f"  Executing tool: {tool_name} with args: {tool_args}")
        tool_result = search_tool.invoke(tool_args["query"])
    else:
        raise ValueError(f"Unknown tool: {tool_name}")

    # Add the tool's output back to the chat history as a ToolMessage
    return {"chat_history": [ToolMessage(content=tool_result, tool_call_id=tool_call["id"])]}

# --- 4. Define the Conditional Edge Logic ---

def should_continue(state: AgentState) -> str:
    """
    Decides whether to continue to a tool call or end the graph.
    Based on if the last LLM message has 'tool_calls'.
    """
    last_message = state["chat_history"][-1]
    if last_message.tool_calls:
        print("\n--- Conditional Edge: LLM suggested tool call. Routing to TOOL node. ---")
        return "continue_tool"
    else:
        print("\n--- Conditional Edge: LLM provided final answer. Routing to END. ---")
        return "end_response"

def run_langgraph_conditional_agent():
    print("--- Running LangGraph Conditional Agent ---")

    # --- 5. Build the LangGraph Workflow ---
    workflow = StateGraph(AgentState)

    # Add nodes to the workflow
    workflow.add_node("llm", call_llm) # Node for LLM interaction
    workflow.add_node("tool", call_tool) # Node for tool execution

    # Set the entry point for the graph
    workflow.set_entry_point("llm")

    # Add conditional edges from the 'llm' node
    # The 'should_continue' function determines the next step.
    workflow.add_conditional_edges(
        "llm",                  # Source node
        should_continue,        # Function to determine which branch to take
        {
            "continue_tool": "tool", # If LLM suggests a tool, go to 'tool' node
            "end_response": END      # If LLM gives final answer, end the graph
        }
    )

    # After the tool is called, always go back to the LLM
    # The LLM then processes the tool's output and decides the next step (e.g., final answer or another tool)
    workflow.add_edge("tool", "llm")

    # Compile the graph
    app = workflow.compile()

    # --- 6. Invoke the Graph ---

    print("\n\n=== Interaction 1: Requires Web Search ===")
    user_query_1 = "What is the capital of Canada?"
    print(f"User: {user_query_1}")
    inputs_1 = {"chat_history": [HumanMessage(content=user_query_1)]}
    for s in app.stream(inputs_1):
        if "__end__" not in s:
            print(s)
    print("\nFinal Result of Interaction 1:")
    print(app.invoke(inputs_1)["chat_history"][-1].content)


    print("\n\n=== Interaction 2: Direct LLM Response ===")
    user_query_2 = "Tell me a fun fact about giraffes."
    print(f"User: {user_query_2}")
    inputs_2 = {"chat_history": [HumanMessage(content=user_query_2)]}
    for s in app.stream(inputs_2):
        if "__end__" not in s:
            print(s)
    print("\nFinal Result of Interaction 2:")
    print(app.invoke(inputs_2)["chat_history"][-1].content)

if __name__ == "__main__":
    run_langgraph_conditional_agent()

import os
from dotenv import load_dotenv
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.utils.function_calling import format_tool_to_openai_function

# Load environment variables
load_dotenv()

class HumanInLoopState(TypedDict):
    chat_history: Annotated[List[BaseMessage], lambda x, y: x + y]
    proposed_action: str # Stores the action the LLM wants to take
    human_approved: Annotated[bool | None, lambda x, y: y] # Flag for human approval, always take latest

# Initialize LLM and tools
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# llm = ChatOllama(model="llama3", temperature=0) # For Ollama

# Mock a "critical" tool
@tool
def update_customer_record(customer_id: str, new_status: str) -> str:
    """Updates the status of a customer record in the CRM."""
    print(f"\n[CRITICAL TOOL EXECUTION]: Updating customer {customer_id} to status: {new_status}")
    return f"Customer {customer_id} status updated to '{new_status}'."

tools = [update_customer_record, DuckDuckGoSearchRun(name="web_search")]
llm_with_tools = llm.bind_functions([format_tool_to_openai_function(t) for t in tools])

# --- Nodes ---
def call_llm_for_decision(state: HumanInLoopState):
    messages = state["chat_history"]
    response = llm_with_tools.invoke(messages)
    return {"chat_history": [response]}

def call_critical_tool(state: HumanInLoopState):
    last_llm_message = state["chat_history"][-1]
    tool_call = last_llm_message.tool_calls[0]
    tool_name = tool_call["name"]
    tool_args = tool_call["args"]

    if tool_name == update_customer_record.name:
        result = update_customer_record.invoke(tool_args)
        return {"chat_history": [ToolMessage(content=result, tool_call_id=tool_call["id"])]}
    else:
        # Fallback for other tools if needed, but here only one critical
        return {"chat_history": [ToolMessage(content="Error: Non-critical tool called in critical path.", tool_call_id=tool_call["id"])]}


def propose_action_for_human(state: HumanInLoopState):
    """LLM's last message is assumed to contain the proposed action (tool call)."""
    last_llm_message = state["chat_history"][-1]
    if last_llm_message.tool_calls:
        proposed_action_str = f"Tool: {last_llm_message.tool_calls[0]['name']}\nArgs: {last_llm_message.tool_calls[0]['args']}"
        print(f"\n--- HUMAN INTERVENTION REQUIRED ---")
        print(f"Agent proposes: {proposed_action_str}")
        print("Please approve or reject this action.")
        return {"proposed_action": proposed_action_str}
    return {"proposed_action": "No specific tool action proposed."} # Should not happen if routed correctly

# --- Conditional Edge Logic ---
def route_decision_or_human_review(state: HumanInLoopState) -> str:
    last_llm_message = state["chat_history"][-1]
    if last_llm_message.tool_calls:
        # If the LLM wants to call the 'update_customer_record' tool, go to human review
        if last_llm_message.tool_calls[0]["name"] == update_customer_record.name:
            print("\n--- Routing: Critical tool detected. -> HUMAN_REVIEW node ---")
            return "human_review"
        else:
            # Other tools can be executed directly (e.g., web_search)
            print("\n--- Routing: Non-critical tool detected. -> TOOL_EXECUTION node ---")
            return "tool_execution"
    else:
        print("\n--- Routing: LLM provided final answer. -> END ---")
        return "end_response"

def route_after_human_review(state: HumanInLoopState) -> str:
    if state.get("human_approved"):
        print("\n--- Routing: Human Approved. -> TOOL_EXECUTION node ---")
        return "execute_approved_action"
    else:
        print("\n--- Routing: Human Rejected. -> REVISION node ---")
        return "revision_required"

def run_langgraph_human_in_loop():
    print("--- Running LangGraph Human-in-the-Loop Agent ---")

    workflow = StateGraph(HumanInLoopState)

    workflow.add_node("llm_decision", call_llm_for_decision)
    workflow.add_node("human_review", propose_action_for_human)
    workflow.add_node("tool_execution", call_critical_tool) # This node now handles both direct and approved tool execution
    # A revision node could simply be the LLM being prompted to re-evaluate
    workflow.add_node("revision_node", call_llm_for_decision) # For simplicity, reuse LLM for revision

    workflow.set_entry_point("llm_decision")

    # After LLM decision, route to tool execution, human review, or end
    workflow.add_conditional_edges(
        "llm_decision",
        route_decision_or_human_review,
        {
            "tool_execution": "tool_execution", # For non-critical tools (e.g., web search)
            "human_review": "human_review",   # For critical tools (update_customer_record)
            "end_response": END
        }
    )

    # After human review, route based on approval
    workflow.add_conditional_edges(
        "human_review",
        route_after_human_review,
        {
            "execute_approved_action": "tool_execution", # If approved, execute the tool
            "revision_required": "revision_node"        # If rejected, go back to LLM for revision
        }
    )

    # After tool execution, go back to LLM to process tool result
    workflow.add_edge("tool_execution", "llm_decision")

    # If revision is required, send the feedback to LLM
    # Here, we'll manually append a HumanMessage indicating rejection
    workflow.add_edge("revision_node", "llm_decision")

    app = workflow.compile()

    # --- Interaction 1: Critical Action Requiring Approval (Approved) ---
    print("\n\n=== Interaction 1: Update Customer (Approved) ===")
    user_query_1 = "Change customer CUST001's status to 'Premium'."
    print(f"User: {user_query_1}")
    inputs_1 = {"chat_history": [HumanMessage(content=user_query_1)]}

    for step in app.stream(inputs_1):
        if "human_review" in step:
            # Simulate human input
            print("\n(Simulating human approval... typing 'y')")
            # This is where a UI/API would get input. For now, manual.
            step["human_review"]["human_approved"] = True
        print(step)
    print("\nFinal Result of Interaction 1:")
    print(app.invoke(inputs_1)["chat_history"][-1].content)


    # --- Interaction 2: Critical Action Requiring Approval (Rejected) ---
    print("\n\n=== Interaction 2: Update Customer (Rejected) ===")
    user_query_2 = "Change customer CUST002's status to 'Deactivated'."
    print(f"User: {user_query_2}")
    inputs_2 = {"chat_history": [HumanMessage(content=user_query_2)]}

    for step in app.stream(inputs_2):
        if "human_review" in step:
            # Simulate human input
            print("\n(Simulating human rejection... typing 'n')")
            step["human_review"]["human_approved"] = False
        print(step)
    print("\nFinal Result of Interaction 2:")
    print(app.invoke(inputs_2)["chat_history"][-1].content) # This should show the LLM recognizing rejection.


    # --- Interaction 3: Non-critical action (no approval) ---
    print("\n\n=== Interaction 3: Non-critical Search ===")
    user_query_3 = "What is the capital of France?"
    print(f"User: {user_query_3}")
    inputs_3 = {"chat_history": [HumanMessage(content=user_query_3)]}
    for s in app.stream(inputs_3):
        if "__end__" not in s:
            print(s)
    print("\nFinal Result of Interaction 3:")
    print(app.invoke(inputs_3)["chat_history"][-1].content)

if __name__ == "__main__":
    run_langgraph_human_in_loop()

import os
from dotenv import load_dotenv
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.utils.function_calling import format_tool_to_openai_function
from langgraph.checkpoint.sqlite import SqliteSaver # For persisting state

# Load environment variables
load_dotenv()

class PersistentAgentState(TypedDict):
    chat_history: Annotated[List[BaseMessage], lambda x, y: x + y]
    # We could add more state variables relevant to the multi-step task, e.g.,
    # loan_application_data: dict # To store collected info

# Initialize LLM (no tools needed for this simple memory demo)
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# llm = ChatOllama(model="llama3", temperature=0) # For Ollama
llm_no_tools = llm # No tools bound for this specific example

def call_llm_for_conversation(state: PersistentAgentState):
    """Simple LLM node for conversational responses."""
    messages = state["chat_history"]
    response = llm_no_tools.invoke(messages)
    return {"chat_history": [response]}

def run_langgraph_persistence():
    print("--- Running LangGraph Persistent Agent ---")

    # 1. Initialize the SqliteSaver checkpointer
    # This will create 'langgraph_checkpoint.sqlite' file to store states.
    # For a real app, you'd configure a proper database.
    memory = SqliteSaver.from_conn_string("langgraph_checkpoint.sqlite")
    print(f"Checkpoints will be saved/loaded from: langgraph_checkpoint.sqlite")

    # 2. Build a simple conversational workflow
    workflow = StateGraph(PersistentAgentState)
    workflow.add_node("chatbot", call_llm_for_conversation)
    workflow.set_entry_point("chatbot")
    workflow.add_edge("chatbot", END) # Simple direct response and end

    # 3. Compile the graph with the checkpointer
    # `checkpointer` is the key for persistence.
    app = workflow.compile(checkpointer=memory)

    session_id_1 = "user_loan_session_123"
    session_id_2 = "user_loan_session_456"

    # --- Interaction 1: First Session ---
    print(f"\n=== Session: {session_id_1} - Starting New Conversation ===")
    user_query_1_1 = "Hi, I'm starting a loan application. What information do you need first?"
    print(f"User [{session_id_1}]: {user_query_1_1}")
    inputs_1_1 = {"chat_history": [HumanMessage(content=user_query_1_1)]}
    response_1_1 = app.invoke(inputs_1_1, config={"configurable": {"thread_id": session_id_1}})
    print(f"Agent [{session_id_1}]: {response_1_1['chat_history'][-1].content}")

    user_query_1_2 = "My annual income is $75,000."
    print(f"User [{session_id_1}]: {user_query_1_2}")
    inputs_1_2 = {"chat_history": [HumanMessage(content=user_query_1_2)]}
    response_1_2 = app.invoke(inputs_1_2, config={"configurable": {"thread_id": session_id_1}})
    print(f"Agent [{session_id_1}]: {response_1_2['chat_history'][-1].content}")

    print(f"\n--- User for {session_id_1} leaves and comes back later ---")

    # --- Interaction 1 (continued): Resume Session ---
    user_query_1_3 = "What was my income again?"
    print(f"User [{session_id_1}]: {user_query_1_3}")
    # LangGraph will automatically load the state for session_id_1
    inputs_1_3 = {"chat_history": [HumanMessage(content=user_query_1_3)]}
    response_1_3 = app.invoke(inputs_1_3, config={"configurable": {"thread_id": session_id_1}})
    print(f"Agent [{session_id_1}]: {response_1_3['chat_history'][-1].content}")

    # --- Interaction 2: A Completely Separate Session ---
    print(f"\n=== Session: {session_id_2} - Starting New Conversation ===")
    user_query_2_1 = "I need information on starting a new business. What are the first steps?"
    print(f"User [{session_id_2}]: {user_query_2_1}")
    inputs_2_1 = {"chat_history": [HumanMessage(content=user_query_2_1)]}
    response_2_1 = app.invoke(inputs_2_1, config={"configurable": {"thread_id": session_id_2}})
    print(f"Agent [{session_id_2}]: {response_2_1['chat_history'][-1].content}")

    print("\n--- You can now check the 'langgraph_checkpoint.sqlite' file for saved states. ---")
    print("You can rerun this script, and session_id_1 will still remember previous turns.")


if __name__ == "__main__":
    # Clean up old checkpoint file for a fresh start each time (optional)
    if os.path.exists("langgraph_checkpoint.sqlite"):
        os.remove("langgraph_checkpoint.sqlite")
        print("Removed existing langgraph_checkpoint.sqlite for a clean run.")

    run_langgraph_persistence()

import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun

# Load environment variables
load_dotenv()

def run_sequential_blog_post_crew():
    print("--- Running Sequential Blog Post Crew ---")

    # 1. Initialize the LLM (for all agents in this example)
    llm = ChatOpenAI(model="gpt-4o", temperature=0.7) # GPT-4o often better for complex reasoning/writing
    # llm = ChatOllama(model="llama3", temperature=0.7) # For Ollama (ensure it's capable for writing)

    # 2. Define Tools
    search_tool = DuckDuckGoSearchRun()
    available_tools = [search_tool]

    # 3. Create Agents
    # Each agent has a distinct role, goal, backstory, and assigned tools/LLM.
    researcher = Agent(
        role='Senior Research Analyst',
        goal='Uncover the latest groundbreaking trends and advancements in AI',
        backstory='''You are a highly skilled and diligent research analyst with a keen eye for
        identifying emerging patterns and disruptive technologies in the AI landscape.
        Your reports are thorough, insightful, and always up-to-date.''',
        verbose=True,
        allow_delegation=False, # This agent focuses solely on research, doesn't delegate.
        tools=available_tools,   # Only the researcher needs the search tool.
        llm=llm
    )

    writer = Agent(
        role='Professional Content Writer',
        goal='Craft compelling and informative blog posts about AI trends',
        backstory='''You are a prolific content writer with a talent for transforming complex
        technical information into engaging and accessible blog posts. Your writing is
        clear, concise, and captivating.''',
        verbose=True,
        allow_delegation=False, # This agent focuses solely on writing.
        llm=llm
    )

    # 4. Define Tasks
    # Tasks are assigned to specific agents and define what needs to be done.
    # The output of the research_task will implicitly be passed to the write_blog_post_task.
    research_task = Task(
        description='''Conduct a comprehensive analysis of the most recent advancements
        in Agentic AI frameworks, focusing on LangChain, LangGraph, and CrewAI.
        Identify key features, use cases, and notable examples.
        Your final answer MUST be a detailed, well-structured research report, at least 500 words,
        summarizing your findings, including sources (if found).''',
        expected_output='A detailed research report, markdown formatted, covering Agentic AI frameworks with key features, use cases, examples, and sources.',
        agent=researcher
    )

    write_blog_post_task = Task(
        description='''Write an engaging and informative blog post (minimum 800 words)
        based on the research report provided by the Senior Research Analyst.
        The blog post should be structured with an introduction, several body paragraphs
        (each focusing on a specific framework or aspect), and a conclusion.
        The tone should be informative yet accessible to a general tech audience.
        Ensure to cite sources from the research report where appropriate.
        Your final answer MUST be the complete blog post in markdown format.''',
        expected_output='A complete blog post, at least 800 words, in markdown format, based on the provided research.',
        agent=writer,
        context=[research_task] # Explicitly pass the output of research_task as context
    )

    # 5. Instantiate the Crew
    # `Process.sequential` means tasks are executed in the order they are defined.
    project_crew = Crew(
        agents=[researcher, writer],
        tasks=[research_task, write_blog_post_task],
        process=Process.sequential,
        verbose=True, # Show all agents' internal reasoning
        llm=llm # Default LLM for tasks if not explicitly set on agent, or for overall crew management
    )

    # 6. Kickoff the Crew's work
    print("\n\n### CREW KICKOFF: Starting Research and Blog Post Generation ###")
    result = project_crew.kickoff()
    print("\n### CREW FINISHED ###")
    print("\n## FINAL BLOG POST ##")
    print(result)

if __name__ == "__main__":
    run_sequential_blog_post_crew()

import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
# from langchain_community.chat_models import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun

# Load environment variables
load_dotenv()

def run_hierarchical_marketing_plan_crew():
    print("--- Running Hierarchical Marketing Plan Crew ---")

    # 1. Initialize LLMs
    # Manager needs a powerful LLM for delegation and review.
    # Other agents can use slightly less powerful ones if desired, or the same.
    manager_llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
    agent_llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
    # manager_llm = ChatOllama(model="llama3", temperature=0.7) # For Ollama
    # agent_llm = ChatOllama(model="llama3", temperature=0.5) # For Ollama

    # 2. Define Tools (all agents have access to web search for general info)
    search_tool = DuckDuckGoSearchRun()
    shared_tools = [search_tool]

    # 3. Create Agents
    # The 'manager' agent needs `allow_delegation=True`.
    marketing_strategist = Agent(
        role='Senior Marketing Strategist',
        goal='Create a comprehensive marketing plan for a new product launch',
        backstory='''You are an experienced marketing strategist responsible for overseeing campaigns,
        delegating tasks, and ensuring all marketing efforts align with the product's goals.
        You are an expert in market analysis and campaign design.''',
        verbose=True,
        allow_delegation=True, # IMPORTANT: This agent can delegate to others.
        llm=manager_llm # Use the more powerful LLM for the manager
    )

    copywriter = Agent(
        role='Creative Copywriter',
        goal='Develop compelling and persuasive marketing copy for various channels',
        backstory='''You are a talented copywriter known for crafting engaging and effective
        messages that resonate with target audiences and drive action.''',
        verbose=True,
        allow_delegation=False,
        tools=shared_tools,
        llm=agent_llm
    )

    social_media_expert = Agent(
        role='Social Media Expert',
        goal='Design an engaging social media strategy and content plan',
        backstory='''You are a specialist in social media, adept at identifying trends,
        crafting viral content, and optimizing campaigns for maximum reach and engagement.''',
        verbose=True,
        allow_delegation=False,
        tools=shared_tools,
        llm=agent_llm
    )

    # 4. Define Tasks (initial high-level tasks, manager will break them down)
    product_name = "EcoSmart Home Hub"
    product_description = "A smart home device that optimizes energy usage and promotes sustainable living, managed via an intuitive app."

    market_research_task = Task(
        description=f'''Conduct market research for a new product called "{product_name}".
        Identify the target audience, analyze competitors in the sustainable smart home market,
        and find unique selling propositions (USPs).''',
        expected_output='A detailed market research report including target audience, competitor analysis, and 3-5 key USPs for the product.',
        agent=marketing_strategist, # Manager can start, but will likely delegate parts.
        async_execution=True # For hierarchical, tasks can run asynchronously
    )

    copy_creation_task = Task(
        description=f'''Develop core marketing copy for "{product_name}". This includes a compelling tagline,
        short descriptive text (2-3 sentences), and a longer product description (1-2 paragraphs).
        Focus on sustainability, ease of use, and innovation.''',
        expected_output='A set of marketing copy: tagline, short description, long description, all emphasizing product benefits.',
        agent=copywriter, # Assigned to copywriter
        async_execution=True
    )

    social_media_task = Task(
        description=f'''Create a social media content strategy for the launch of "{product_name}".
        Suggest 3-5 post ideas for Instagram and X (formerly Twitter), including hashtags and calls to action.
        Focus on driving engagement and explaining the eco-benefits.''',
        expected_output='A social media strategy document with 3-5 post ideas for Instagram and X, including content, hashtags, and CTAs.',
        agent=social_media_expert, # Assigned to social media expert
        async_execution=True
    )

    final_plan_task = Task(
        description=f'''Compile all gathered research, copy, and social media strategy into a cohesive
        "EcoSmart Home Hub" Marketing Launch Plan. Provide an executive summary and outline next steps.
        Your final answer MUST be the complete marketing launch plan in markdown format.''',
        expected_output='A full marketing launch plan in markdown format, summarizing all findings and strategies.',
        agent=marketing_strategist, # Manager compiles the final plan
        context=[market_research_task, copy_creation_task, social_media_task] # Manager will use outputs of other tasks
    )

    # 5. Instantiate the Crew with Hierarchical Process
    # `Process.hierarchical` enables delegation and a "manager_llm" to oversee.
    marketing_crew = Crew(
        agents=[marketing_strategist, copywriter, social_media_expert],
        tasks=[market_research_task, copy_creation_task, social_media_task, final_plan_task],
        process=Process.hierarchical, # IMPORTANT: Hierarchical process
        verbose=True,
        manager_llm=manager_llm # The LLM used by the manager agent for delegation/review
    )

    # 6. Kickoff the Crew
    print("\n\n### CREW KICKOFF: Starting Hierarchical Marketing Plan Generation ###")
    result = marketing_crew.kickoff()
    print("\n### CREW FINISHED ###")
    print("\n## FINAL MARKETING PLAN ##")
    print(result)

if __name__ == "__main_":
    run_hierarchical_marketing_plan_crew()

import os
from dotenv import load_dotenv
from langchain_community.chat_models import ChatOllama # Use ChatOllama for local LLM
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain.memory import ConversationBufferMemory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage

# Load environment variables (might not be strictly needed for Ollama, but good practice)
load_dotenv()

def run_ollama_agent_deployment():
    print("--- Running Ollama-Powered Conversational Agent ---")
    print("!!! ENSURE 'ollama run llama3' IS RUNNING IN A SEPARATE TERMINAL !!!")

    # 1. Initialize the LOCAL LLM using ChatOllama
    # Connects to your local Ollama server running the 'llama3' model.
    # Adjust `model` if you pulled a different one (e.g., "mistral").
    ollama_llm = ChatOllama(model="llama3", temperature=0)

    # 2. Define tools (web search for current info)
    search_tool = DuckDuckGoSearchRun(name="duckduckgo_search")
    tools = [search_tool]

    # 3. Get a conversational ReAct agent prompt from LangChain Hub
    prompt = hub.pull("hwchase17/react-chat-json")

    # 4. Create the agent with the Ollama LLM
    agent = create_react_agent(ollama_llm, tools, prompt)

    # 5. Create the Agent Executor
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True
    )

    # 6. Initialize ConversationBufferMemory
    memory = ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )

    # 7. Wrap the agent executor with RunnableWithMessageHistory for session memory
    conversational_agent = RunnableWithMessageHistory(
        agent_executor,
        lambda session_id: memory,
        input_messages_key="input",
        history_messages_key="chat_history"
    )

    # 8. Engage in a conversation
    session_id = "ollama_user_session_001"

    print("\n--- Ollama Agent Turn 1 ---")
    user_input_1 = "Hi. My name is Sam. What is the tallest mountain in North America?"
    print(f"User [{session_id}]: {user_input_1}")
    response_1 = conversational_agent.invoke(
        {"input": user_input_1},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent [{session_id}]: {response_1['output']}")

    print("\n--- Ollama Agent Turn 2 ---")
    user_input_2 = "And what was my name again? Also, what's the population of your closest major city?"
    print(f"User [{session_id}]: {user_input_2}")
    response_2 = conversational_agent.invoke(
        {"input": user_input_2},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent [{session_id}]: {response_2['output']}")

    print("\n--- Ollama Agent Turn 3 ---")
    user_input_3 = "Thanks! What is Denali's elevation?"
    print(f"User [{session_id}]: {user_input_3}")
    response_3 = conversational_agent.invoke(
        {"input": user_input_3},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\nAgent [{session_id}]: {response_3['output']}")

if __name__ == "__main__":
    run_ollama_agent_deployment()