AI Agents

Building AI that acts, not just talks — the LLM brain, tools, memory and planning, the ReAct framework, state management and LangGraph.

From Chatbots to Agents

The Brain, Hands & Instructions

Every agent is built from three pillars:

The Brain — an LLM is a probabilistic prediction engine

The LLM brain is a "next-word predictor", not a sentient mind. It has a training phase (learns patterns by minimising prediction error on huge text data) and a decoding phase (generates text by producing a probability distribution over the next token). Decoding strategies: greedy search (always pick the most likely word) or stochastic sampling (get creative, controlled by temperature/top-p).

Why a "naked" LLM is not enough

Tools & the Agentic Loop

Common tools: web search (real-time info), calculator (precise maths), API requests (weather, stock prices, email), code interpreter (run code, analyse data).

The agentic workflow loop

Example: "Is it raining in London?" → the LLM reasons "I need real-time data" → selects the Weather tool → the system executes it and returns "Rainy, 12°C" → the LLM synthesises "Yes, it is raining in London." The hallmark of a true agent is that moment when the model stops generating text and instead writes a command to call a tool.

from langchain_core.tools import tool

# 1. Define a tool - a normal function with a docstring
@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers together."""
    return a * b

# 2. Bind the tool to the LLM (the "calculator" is handed over)
llm_with_tools = llm.bind_tools([multiply])

# 3. The LLM does not answer directly - it requests the tool
response = llm_with_tools.invoke("Calculate 50 times 173")
print("Tool call:", response.tool_calls)

Notice the LLM did not compute the answer itself — it recognised it needs the tool and produced a structured tool call. The system then runs multiply(50, 173) = 8650 and feeds the result back.

Memory & Planning

Memory Management

Short-term memory handles the "what" of the current task; long-term memory stores the "who" and user preferences for personalised experiences.

Planning & Goal Decomposition

Example — "Plan my vacation" decomposes into: (1) Find flights → (2) Book hotel → (3) List restaurants. Planning makes impossible tasks possible, enables step-by-step progress tracking, and allows error recovery at each step.

Closed vs Open-Source LLMs & Ollama

Why go open source?

• Complete data privacy — prompts and data never leave your device.
• Security & compliance — essential for HIPAA (healthcare), finance, enterprise secrets.
• Offline capability — works without internet once downloaded.
• Cost control — no per-token API fees; predictable fixed costs.

Ollama — the "MP3 player" for AI models

The ReAct Framework

• Think — analyse the situation and decide what action to take.
• Act — execute the chosen action (search, calculate, call an API).
• Observe — review the result and determine the next step.

State Management of AI Agents

State management lets the agent: prevent forgetting previous context, support multi-turn conversations, track progress through complex workflows, and validate inputs.

Types of state (recap)

• Ephemeral — temporary, single-computation values; deleted after use.
• Persistent — survives across steps/sessions (conversation history, preferences); stored via databases/checkpointers.
• Shared — a unified object multiple nodes/agents read and write — crucial for multi-agent collaboration.

Complex Control Flow

Simple chatbots are linear — one straight path. Real agents need complex control flow:

• Branching — choose different paths based on conditions (if price > budget, ask the user; else book).
• Loops / cycles — repeat steps (the ReAct loop; retry a failed tool call).
• Conditional routing — dynamically decide the next node from the current state.
• Human-in-the-loop (HITL) — pause the workflow for human approval before a critical action.

LangGraph: Graphs, Nodes, Edges, State

LangGraph has four core components:

1. State — the shared diary

A typed Python dictionary (TypedDict) passed between every step. Each node reads from it and writes to it, carrying context forward. TypedDict gives type safety and prevents key errors. The add_messages reducer appends new messages instead of overwriting the history.

2. Nodes — the workers

Python functions that perform work. Each node receives the current state, performs an operation (call an LLM, run a tool, compute), and returns updates to the state. Keep each node to a single responsibility.

3. Edges — the logic gates

• Standard edge — a fixed path: Node A → Node B.
• Conditional edge — a dynamic path; a routing function inspects the state and decides which node runs next. Like a GPS that reroutes based on traffic.

4. The StateGraph — the builder

The StateGraph assembles nodes and edges into an executable workflow. Three essential methods: add_node() (register a worker), add_edge() / add_conditional_edges() (connect them), and set_entry_point() (define where execution starts). Finally .compile() turns it into a runnable app.

Building an Agent Graph

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

# State = a typed dictionary shared across all nodes
class AgentState(TypedDict):
    messages: Annotated[list, add_messages]  # add_messages APPENDS
    flight_price: int                        # other fields OVERWRITE
    decision: str

# Node: receives state, returns state updates
def check_price(state: AgentState):
    if state["flight_price"] > 500:
        return {"decision": "ask_user"}
    return {"decision": "book"}

# Routing function for the conditional edge
def route(state: AgentState):
    return "ask" if state["decision"] == "ask_user" else "book"

from langgraph.graph import StateGraph, START, END

builder = StateGraph(AgentState)

# 1. Register nodes (workers)
builder.add_node("find_flight", find_flight)
builder.add_node("check_price", check_price)
builder.add_node("book_flight", book_flight)
builder.add_node("ask_user", ask_user)

# 2. Connect with edges
builder.add_edge(START, "find_flight")
builder.add_edge("find_flight", "check_price")
builder.add_conditional_edges("check_price", route,
                              {"book": "book_flight", "ask": "ask_user"})
builder.add_edge("book_flight", END)

# 3. Compile into a runnable app
app = builder.compile()
result = app.invoke({"flight_price": 0, "decision": "", "messages": []})

from langgraph.prebuilt import ToolNode
from langgraph.graph import StateGraph, START, END

def assistant_node(state):                      # the "Think" node
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

tool_node = ToolNode([multiply])                # the "Act" node

def should_continue(state):                     # router: loop or stop?
    last = state["messages"][-1]
    return "tools" if last.tool_calls else END

builder = StateGraph(State)
builder.add_node("assistant", assistant_node)
builder.add_node("tools", tool_node)
builder.add_edge(START, "assistant")
builder.add_conditional_edges("assistant", should_continue)
builder.add_edge("tools", "assistant")          # loop back -> ReAct cycle
graph = builder.compile()

The edge tools → assistant creates the loop — the agent keeps reasoning and acting until should_continue returns END. That loop is the ReAct cycle implemented as a graph.

Agent components and Ollama commands are common exam material.

from langchain_core.tools import tool

@tool
def string_length(text: str) -> int:
    """Return the number of characters in a string."""
    return len(text)

# Hand the tool to the LLM
llm_with_tools = llm.bind_tools([string_length])

response = llm_with_tools.invoke("How long is the word 'agent'?")
print(response.tool_calls)

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]   # appended each step
    task_status: str                          # overwritten each step

from langgraph.graph import StateGraph, START, END
from langchain_core.messages import AIMessage

def chat_node(state):
    text = state["messages"][-1].content
    return {"messages": [AIMessage(content=f"I heard: {text}")]}

graph = StateGraph(AgentState)
graph.add_node("chat", chat_node)
graph.add_edge(START, "chat")
graph.add_edge("chat", END)

app = graph.compile()

def route(state):
    if state["amount"] > 1000:
        return "approve"      # needs human approval
    return "auto"             # auto-process

builder.add_conditional_edges(
    "check", route,
    {"approve": "approve_node", "auto": "auto_node"}
)