Make your AI answer questions and use tools.#

• Recap 10 seconds

• ✅ Called an LLM with the OpenAI library
• ✅ system / user / assistant messages
• ✅ Key safely in .env
• ✅ Shipped a Summarizer + an LLM Arena

• Block 9 ~5 min · the map

Before you build, remember the three main ways to steer a pre-trained model. You will use the first one most of the time. You will use the second one soon. You will rarely need the third.

• ✍️ 1. PromptingJust tell it clearly. Free, instant, no training. 90% of real work lives here — including everything on this page.
• 📚 2. RAGHand it your documents at question-time so it answers from real data. Coming up next.
• 🎓 3. Fine-tuningActually re-train on examples. Powerful, costly, rarely needed. Reach for it last.

• Block 10 ~35 min · hands-on

With the raw OpenAI API you called the model 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

bash

$ pip install langchain langchain-openai

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:

• ChatPromptTemplate = a prompt with blanksA normal prompt where some parts are left as {blanks} to fill in later. Like a wedding-invite template: "Dear {name}, join us on {date}". Write once, reuse for every guest.
  say it as: "my reusable prompt"
• ChatOpenAI = the model, in a LangChain wrapperThe exact same GPT you called with the raw OpenAI API — just wrapped so it can snap onto other LangChain pieces. Same model=, same temperature=.
  say it as: "the model"
• StrOutputParser = unwraps the answerThe model doesn't return plain text — it returns a package (text + metadata like token counts). This piece opens the package and hands you just the string. ("Str" = string, i.e. plain text.)
  say it as: "give me just the text"

A template is text with blanks. You fill the blanks with a dict. The dict you pass to LangChain, such as {"tone": "witty", ...}, tells LangChain what value goes into each blank.

When the model replies, you do not get plain text. You get a package called an AIMessage. It holds the text and bookkeeping data. The parser opens the package and returns only the text.

A chain is three pieces joined by |, the pipe. Read the pipe as "then": prompt then model then parser.

Rebuilding the earlier website summarizer the LangChain way. The numbered comments match the decoder below — nothing here is mystery code:

summarizer_langchain.py

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 the earlier 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"))

🔍 Decoder — what each numbered line does

1. from_template(...) turns my text into a reusable prompt. The {website} part is the blank — it will be filled in later, just like the playground above.
2. The model. The same model you called with the raw OpenAI API, wrapped for LangChain. temperature=0.3 = mostly focused (summaries shouldn't be wildly creative).
3. The parser. The package-opener you just saw in the animation: takes the model's AIMessage package, hands back plain text.
4. The pipe | means "then". Read aloud: "the prompt, then the model, then the parser." Data flows left → right, exactly like the builder.
5. invoke means "run it". The dict {"website": ...} says which blank gets what — the key "website" matches the {website} blank by name.

Remember the basic 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:

• HumanMessage / AIMessage = labelled chat bubblesJust a way to store "the human said X" and "the AI replied Y" — the same user/assistant roles from the raw OpenAI API, as Python objects.
• MessagesPlaceholder = a parking spot for historyA blank in your prompt that holds a list of past messages instead of one word. "Insert the whole conversation so far, right here."

memory_demo.py

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 the raw API
    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

• Block 11 ~30 min · the leap

Everything so far only talks. An agent is a model with a tool and the freedom to decide when to use it. You will build a small shop assistant with one skill: looking up real prices.

agent = LLM + tool + loop. The model checks, "Do I need a tool here?" If yes, it asks for the tool, reads the result, and answers. You do not hard-code when. That decision is the difference between a chatbot and an agent.

• 👟 shoes — ₹799
• 🧢 hat — ₹399
• 🎒 bag — ₹1420
• 🩳 shorts — ₹1299
• 👖 pants — ₹1699

Step 1 — the tool is just a Python function

agent.py · part 1

import json
from openai import OpenAI
from dotenv import load_dotenv
# ① load the API key and create the OpenAI client
load_dotenv()
client = OpenAI()

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

def get_price(item):
    # ① log the tool call so learners can see when it fired
    print(f"🔧 tool called: get_price({item})")     # show when the tool runs
    # ② look up the item and return a readable price string
    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:

agent.py · part 2

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"],
        },
    },
}]

🔍 Decoder — the menu card, four facts

1. What kind of tool? A function. (That's the only kind you'll use for a long time — just write this line as-is.)
2. Its name — must exactly match your Python function's name, so we can find it when the model asks for it.
3. When to use it — written for the model to read. This sentence is literally how the model decides whether to call your tool. Write it clearly!
4. What inputs it needs — one input called item, which is text ("string"), and it's required. That's all the nesting says.

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

agent.py · part 3

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

🔍 Decoder — the loop, step by step

1. Send message + menu. We send the user's message plus our tools menu. The model now knows a tool exists and may ask to use it.
2. Check for a tool request. msg.tool_calls = "did the model ask to run a tool?" If it did, this holds which tool and with what input — e.g. get_price, item="shoes". If not, it's empty and we skip straight to the answer.
3. Run the tool. The model's request arrives as text, so json.loads(...) converts it into a Python dict we can read — then we run the real function. (Important: the model never runs code itself. It asks; your Python does.)
4. Send it all back. We append the tool's result to the conversation with role: "tool" (a third role, joining system/user/assistant!) and send everything back, so the model can write a friendly final answer using the real data.

The whole agent is a list of messages that gets longer. One question adds four records. These are the same records created by the messages.append(...) lines in the code.

Before you trust the agent, check the rule. For each question, decide whether the model should call the tool or answer directly. The answers and reasons are below.

• Block 12 ~25 min · 🏁 THE BUILD

Same agent() from Block 11 — we give it a simple chat loop in the terminal, so this takes a few lines:

main.py

from agent import agent              # use the function you wrote

while True:                          # ① keep chatting until the user types quit
    message = input("You: ")
    if message.strip().lower() in ("quit", "exit"):
        break
    print("Shop:", agent(message))   # ②

🔍 Decoder

1. The chat loop. input() reads each new message you type, and the loop keeps going until you type quit. We only pass the message today; your homework hint: keep a history list of past turns and pass it into the agent and it gains memory — exactly the trick from the memory section.
2. One agent turn. agent(message) runs the full think → maybe-tool → answer loop, and we print its reply.

Run it

bash — your project folder

$ pip install openai python-dotenv
$ python main.py

You: How much are the pants?
🔧 tool called: get_price(pants)
Shop: The pants are ₹1699.

1. Ask a price question. "How much are the pants?" — watch your terminal print 🔧 tool called: get_price(pants). Your agent used its tool!
2. Then ask small talk. "What's your return policy?" — no tool fires. It's deciding, not following a script.
3. Compare the two. One tool question, one chat question, terminal visible — that contrast is the whole agent idea in 15 seconds.

This trace shows a sample chat with the agent. Watch when the 🔧 tool line appears and when the assistant answers directly.

• Block 14 ~10 min

• 🧭 3 ways to steerPrompting, RAG, fine-tuning — you'll mostly prompt.
• 🔗 LangChainprompt | model | parser — chains you can snap together.
• 🤖 AgentsLLM + tool + loop. The model decides. You saw it.
• 🛍️ You shippedA working tool-using agent. 🎉

1. More tools (your homework). Add check_stock(item) or apply_discount(item) and watch the agent pick the right one.
2. RAG — chat with your own PDFs. The next big build: a model that answers from your documents.
3. Multi-agent teams. Several agents handing work to each other — once one agent feels easy.