Today your AI
stops talking and
starts doing.

Before we build: the entire field of AI engineering boils down to three ways of steering a pre-trained model. You'll live in the first, visit the second soon, and almost never need the third.

In Class 1 you called the API by hand — perfect for one call. The moment you want reusable prompts, multi-step pipelines, and memory, you'd be rebuilding the same plumbing forever. LangChain is that plumbing, pre-built.

Install it

$ pip install langchain langchain-openai

First: the 3 new words, in plain English

LangChain code uses three names that look scary. They aren't. Read these before we touch code — each one is a thing you already understand:

Feel a template (before coding one)

This is all a template is — blanks you fill. Pick values and watch the final prompt assemble. The dict you pass to LangChain ({"tone": "witty", ...}) is just "here's what goes in each blank":

What does the model actually return? (the parser's job)

Here's the bit nobody explains. When the model replies, you don't get plain text — you get a package called an AIMessage with the text inside it, plus bookkeeping. Press the button to see the package, and what the parser does to it:

Now build the chain — literally

A chain is the three pieces joined by | (the pipe — read it as "then"): prompt then model then parser. Click the pieces in the right order, then run data through:

The same chain, in real code — decoded line by line

Rebuilding your Class 1 summarizer the LangChain way. The numbered comments match the decoder below — nothing here is mystery code:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from dotenv import load_dotenv
from scraper import fetch_website_contents   # reuse Class 1's scraper
load_dotenv()

prompt = ChatPromptTemplate.from_template(            # ①
    "Give a short, friendly summary of this website:\n\n{website}")

model  = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)   # ②

parser = StrOutputParser()                             # ③

chain = prompt | model | parser                        # ④

def summarize(url):
    return chain.invoke({"website": fetch_website_contents(url)})   # ⑤

print(summarize("https://anthropic.com"))

Bonus piece — Memory (decoded too)

Class 1 truth: models forget everything between calls. The fix is simple — re-send the old messages every time. LangChain gives that a tidy home. Two tiny new words first:

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a friendly tutor."),     # ① personality, like Class 1
    MessagesPlaceholder("history"),              # ② past turns park here
    ("human", "{question}"),                     # ③ the new question
])
chain = prompt | model

history = [HumanMessage("My name is Aarav."), AIMessage("Hi Aarav!")]
print(chain.invoke({"history": history, "question": "What's my name?"}).content)
# → "Your name is Aarav."  ✅ it "remembered" — because WE re-sent the history

Everything so far talks. An agent is a model with a tool and the freedom to decide when to use it. We'll build the smallest one possible — a shop assistant with exactly one skill: looking up real prices.

Our shop's "database" (kept deliberately tiny)

Step 1 — the tool is just a Python function

import json
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI()

PRICES = {"shoes": 799, "hat": 399, "bag": 1420, "shorts": 1299, "pants": 1699}

def get_price(item):
    print(f"🔧 tool called: get_price({item})")     # so you SEE it happen
    return f"₹{PRICES.get(item.lower(), 'unknown')}"

Two tiny notes for the Python: PRICES is an ordinary dict standing in for a database, and .get(item, 'unknown') means "look it up, and if it's not there, say unknown instead of crashing." That's the entire tool — any function you can write can become an agent's tool.

Step 2 — describe the tool so the model knows it exists

The model can't see your Python. You hand it a menu card describing the tool — written as a dict (the nested braces look busy, but it's only four facts). Decoder below:

tools = [{
    "type": "function",                                      # ①
    "function": {
        "name": "get_price",                                 # ②
        "description": "Get the price of a shop item the user asks about.",  # ③
        "parameters": {                                       # ④
            "type": "object",
            "properties": {"item": {"type": "string", "description": "the item name"}},
            "required": ["item"],
        },
    },
}]

Step 3 — the loop: think → maybe call tool → answer

def agent(user_message):
    messages = [{"role": "user", "content": user_message}]

    response = client.chat.completions.create(          # ① send message + tools menu
        model="gpt-4o-mini", messages=messages, tools=tools)
    msg = response.choices[0].message

    if msg.tool_calls:                                  # ② did it ask for a tool?
        messages.append(msg)
        for call in msg.tool_calls:
            args = json.loads(call.function.arguments)  # ③ read its request, run it
            result = get_price(args["item"])
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
        response = client.chat.completions.create(      # ④ send it all back → nice answer
            model="gpt-4o-mini", messages=messages)
        msg = response.choices[0].message

    return msg.content

print(agent("How much are the shoes?"))      # → tool fires → "₹799"
print(agent("Hi! What can you help with?"))   # → no tool → just chats

Watch the conversation grow (this makes it click)

The whole agent is just a list of messages getting longer. Step through one question and watch each card get appended — this is exactly what your code's messages.append(...) lines do:

🎮 Quick game: think like the agent

Before you trust the agent, prove you understand it. For each question, predict: will the model call the tool or answer directly? Get 5 in a row:

Same agent() from Block 11 — we give it a face. Gradio has a ready-made chat interface, so this takes four lines:

import gradio as gr
from agent import agent              # the function you just wrote

def chat(message, history):          # ① Gradio fills these two in for you
    return agent(message)

gr.ChatInterface(fn=chat, title="🛍️ Smart Shop Assistant").launch(share=True)  # ②

Run it

$ pip install openai gradio python-dotenv
$ python app.py

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://shop-xyz.gradio.live   # ← your shareable agent!

Try the working agent 👇

A live, in-browser version with the real chat feel — typing dots, tool-call chips, the works. Watch when the 🔧 appears (and when it doesn't):

⚙️ Simulated in-browser (keyword matching plays the "model") so it runs key-free. Your real agent.py lets GPT make that decision far more flexibly — same loop, same trace.

"I built an AI agent" lands harder than "I built a chatbot" — because most people have no idea how simple the trick is. Post the clip, use this caption, and hit the big button below when you're live. 😄

👉 Tag linkedin.com/in/shivankagrawal and @Scaler so we can reshare and boost your reach.

The road ahead (still hands-on)