By the end, you will have shipped two AI apps.#

AI is not new. It is 70 years old. So why did it show up in your feed only recently? Two things changed. They changed what you can build.

1. 1950s–2000s — AI is a research lab thing. Decades of slow progress. You needed a PhD, a university, and years to do anything useful.
2. 2017 — The “Transformer” is invented. A new model design learns language very well. This is the engine inside GPT, Claude, Gemini.
3. Nov 2022 — ChatGPT launches. The fastest-adopted product in history. Suddenly everyone can talk to AI.
4. Now → you — anyone can build on top of it. Giant labs do the hardest part. You call their AI with a few lines of code. That is what you will learn here.

LLM = Large Language Model. In simple terms, it does one thing very well: it predicts the next chunk of text. Chat, code and summaries all build on that one trick.

A model does not read letters or full words. It reads tokens, which are pieces roughly ¾ of a word. It thinks in tokens and you pay per token. Here is a worked example.

But why tokens — why not just whole words, or single letters?

This is an engineering trade-off. The model needs a fixed list of "things it knows" (its vocabulary). Whole words and single letters both cause problems. Tokens sit in the useful middle:

• ❌ One token per wordThere are millions of words across all languages, plus names, typos, slang and new words every day. The vocabulary would be too large, and it would fail on a word it had never seen.
• ❌ One token per letterThere are only ~100 symbols, so the vocabulary is small. But every sentence becomes hundreds of tokens. That is slow and expensive, and the model has to learn spelling from scratch.
• ✅ Tokens (sub-words)A vocabulary of ~100k common chunks. Frequent words stay whole. Rare words are built from pieces. This is compact, and it can spell any new word.

Here is a concrete example. A rare word still works because it is assembled from familiar pieces:

How a rare word gets built: "unbelievableness" → un believ able ness

Four known tokens are enough. Meanwhile "the", "cat", "is" are each a single token. That is why tokens were chosen. One fixed vocabulary can handle every word in every language, even words invented tomorrow.

Given the tokens so far, the model gives every possible next token a probability. It picks one, adds it, and repeats. That loop is “generating text”.

Between API calls, an LLM forgets everything. Anything it should "know" in a conversation must be re-sent every time, inside a limited context window (measured in tokens). This fact explains a large part of AI engineering.

• 🔤 Tokens, not wordsIt reads, reasons and bills in tokens.
• 🎯 Predicts next tokenAll abilities emerge from this loop.
• 🌡️ TemperatureLow = focused, high = creative.
• 🪟 No memoryYou resend context each time.

Here is the core idea. How do you teach a machine language without humans labelling billions of examples? You let it play fill-in-the-blank with the entire internet.

Here is the hidden-word example:

First, update your mental model. Modern AI is not just text. It can also see, hear and speak. We call these foundation models: one giant general-purpose model that you adapt to many jobs.

flowchart LR
  T[📝 Text] --> M((🧠 Foundation Model))
  I[🖼️ Images] --> M
  A[🎤 Audio] --> M
  V[🎬 Video] --> M
  M --> O1[💬 An answer]
  M --> O2[🖌️ An image]
  M --> O3[🔊 A voice]
  M --> O4[📊 A report]
                                

Almost every AI product you have seen fits one of these groups. Find your idea here:

• 💻 CodingWrite, explain & fix code. The number 1 use case today. Copilot · Cursor
• ✍️ WritingEmails, blogs, marketing copy, rewriting. Jasper · Notion AI
• 🎨 Image & VideoGenerate art, edit photos, make clips. Midjourney
• 🎓 EducationPersonal tutors that explain anything at your pace. Khanmigo
• 💬 ChatbotsSupport, sales & assistants that converse. Intercom Fin
• 📥 Info AggregationSummarise and search across large amounts of text. ★ this project
• 🗂️ Data OrganizationTag, sort & structure messy information. classification
• ⚙️ Workflow / AgentsAI that takes multi-step actions for you. the frontier

Here we build a 📥 Info-Aggregation tool — an AI Website Summarizer. It is simple, useful and easy to share.

One line: AI Engineering is building real products on top of pre-trained models (GPT, Claude, Gemini) — without training those models yourself.

The car analogy. A Machine Learning engineer builds the engine. An AI Engineer builds the car around an engine someone else already built — wiring it to your data, your users, your problem, so it actually ships. You do not forge the engine. You drive.

Before any code runs, three quick bits of plumbing. Do not worry — it is a one-time setup.

① Install a code editor — Cursor or VS Code

You need one editor to write and run code. Both are free and work identically for this course — pick whichever you like:

1. Download & install. Cursor: go to cursor.com → Download. VS Code: go to code.visualstudio.com → Download. Install it like any normal app (Windows / Mac / Linux).
2. Add the Python & Jupyter extensions. Open your editor → click the Extensions icon on the left → search Python (by Microsoft) and Jupyter → Install both. (Same steps in Cursor and VS Code.)
3. Open a notebook & pick the kernel. Open a .ipynb file → click Select Kernel (top-right) → choose your Python environment. You run a cell with Shift + Enter.

② Get your OpenAI API key

An API key is a secret password that lets your code use OpenAI's models (you pay only for what you use — cents for everything here). Here are the setup steps:

③ Put the key in a .env file (never in your code)

Create a file literally named .env in your project folder, and paste your key inside. Your code reads it from there — so the secret never appears in the code you share.

# .env  — keep this file private! Add it to .gitignore
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx

# pip install python-dotenv
from dotenv import load_dotenv
# ① load secret values from .env into your environment
load_dotenv()                 # loads everything from .env

# now OpenAI() finds the key automatically — no key in your code 🎉

After setup, calling an LLM is an API call. It is like fetching the weather, but the reply is generated by a model. Here is the full example:

# pip install python-dotenv
from dotenv import load_dotenv
# pip install openai
from openai import OpenAI
# ① load the API key from .env so the client can find it
load_dotenv()                 # loads everything from .env

# ② create the OpenAI client that will send chat requests
client = OpenAI()   # reads your API key from the environment

# ③ ask the model with a system role and a user question
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a witty travel guide."},
        {"role": "user",   "content": "Suggest one thing to do in Bangalore."},
    ],
)
# ④ print the assistant message from the first choice
print(response.choices[0].message.content)


# now OpenAI() finds the key automatically — no key in your code 🎉

• system — sets the personality and rules — "You are a careful tutor. Never give the full answer." Written once, applies throughout.
• user — what the human asks. The actual request.
• assistant — the model's reply. To continue a chat, append it back and resend the whole list (remember: no memory!).

If you do not want to add billing yet, Groq gives you a free API key and runs open models like Meta's Llama very fast. Because Groq speaks the same "language" as OpenAI, you change just two things — the key and one line — and everything else stays identical:

# pip install openai   (yes — the same library!)
import os
from openai import OpenAI
from dotenv import load_dotenv
# ① load environment variables for the Groq key
load_dotenv()

# ② point the SAME client at Groq instead of OpenAI 👇
client = OpenAI(
    api_key=os.getenv("GROQ_API_KEY"),
    base_url="https://api.groq.com/openai/v1",
)

# ③ ask the Llama model the same travel-guide question
response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",        # a free Llama model on Groq
    messages=[
        {"role": "system", "content": "You are a witty travel guide."},
        {"role": "user",   "content": "Suggest one thing to do in Bangalore."},
    ],
)
# ④ print the assistant message from the first choice
print(response.choices[0].message.content)

Where to get the key. Sign up free at console.groq.com → API Keys → Create key, then add it to your .env as GROQ_API_KEY=gsk_.... Notice that little changed — just the key, the base_url, and the model name. This is a key idea in AI Engineering: the model is swappable.

Now build the app. Our app: give it any web page URL → it reads the page and hands you a clean summary. Think of it as a short digest for the internet. It is simple, genuinely useful, and a good first project to share.

flowchart LR
  U[🔗 URL<br>user pastes it] --> S[🕷️ Scrape<br>grab page text]
  S --> P[🧩 Prompt<br>text + instructions]
  P --> L[🧠 LLM<br>summarise]:::hl
  L --> O[📄 Summary<br>shown to the user]:::good
                                

# pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
}

def fetch_website_contents(url):
    # ① add scheme if the user forgot it
    if not url.startswith(("http://", "https://")):
        url = "https://" + url

    # ② download the page and return a friendly error if it fails
    try:
        response = requests.get(url, headers=HEADERS, timeout=15)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        return f"Could not fetch the website. Error: {e}"

    # ③ parse the HTML and keep the page title for context
    soup = BeautifulSoup(response.text, "html.parser")
    title = soup.title.string if soup.title else "No title found"

    # ④ remove page chrome so the summary focuses on useful text
    for tag in soup(["script", "style", "nav", "footer", "header", "img", "input"]):
        tag.decompose()

    # ⑤ turn the cleaned page into text for the model
    text = soup.get_text(separator="\n", strip=True)
    return f"Title: {title}\n\nPage contents:\n{text}"

from openai import OpenAI
from dotenv import load_dotenv
from scraper import fetch_website_contents

# ① load the .env file so OpenAI can read the API key
load_dotenv()          # <-- this reads your .env file
# ② create the model client once so summarize can reuse it
client = OpenAI()

# ③ define the website-summary instructions for the model
system_prompt = """You analyze the contents of a website and
give a short, friendly summary. Ignore navigation menus.
Respond in markdown."""

def summarize(url):
    # ① scrape the page so the model receives text instead of a URL
    website = fetch_website_contents(url)
    # ② send the scraped text to the chat model with the system prompt
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role":"system", "content": system_prompt},
            {"role":"user",   "content": f"Summarize this website:\n\n{website}"},
        ],
    )
    # ③ return only the assistant's written summary
    return response.choices[0].message.content

Step 3 — The entry point

A tiny main.py asks for a URL and prints the summary:

from summarizer import summarize

# ① ask the learner which website to summarize
url = input("Website URL: ")
# ② summarize that URL and print the model response
print(summarize(url))

Step 4 — Run it on your machine

Save the three files (scraper.py, summarizer.py, main.py) and your .env in one folder. Then open the terminal in Cursor (Terminal → New Terminal) and run:

# 1. install everything you need (one time)
$ pip install openai requests beautifulsoup4 python-dotenv

# 2. run the app
$ python main.py

# 3. paste a URL when asked
Website URL: https://example.com

1. Paste a URL and press Enter. Try a blog or news site. In a second or two, the summary prints in your terminal. You just used your own AI app.
2. Stop it anytime. Press Ctrl + C in the terminal to shut the app down; run python main.py again for another page.

Below is a sample run of that app. It shows the sample sites, the personalities and the outputs.

⚙️ This demo summarizes in your browser (a simple method) so it runs with no API key. Your real summarizer.py sends the text to GPT for a smarter summary — but the shape, the flow, and the personality switch are exactly what you see here.

Here is a second mini-project. Inspired by arena.ai, where people send one prompt to two AIs and vote on the better answer — that is how many people rank AI models. You can build a tiny version with what you already know: send the same prompt to two models, show both answers side by side.

def battle(prompt):
    # ① wrap the learner prompt in the chat format both models expect
    msgs = [{"role": "user", "content": prompt}]

    # ② ask Model A — OpenAI's GPT
    a = openai_client.chat.completions.create(model="gpt-4o-mini", messages=msgs)

    # ③ ask Model B — Llama on Groq (same code, different brain!)
    b = groq_client.chat.completions.create(model="llama-3.3-70b-versatile", messages=msgs)

    # ④ return both answers so the app can compare them
    return a.choices[0].message.content, b.choices[0].message.content
# …now we turn this into a tiny terminal app with 👍/👎 voting 👇

The full app with A/B voting

# pip install openai python-dotenv
import os
from openai import OpenAI
from dotenv import load_dotenv
# ① load API keys for both providers
load_dotenv()

# ② create one client for OpenAI and one for Groq
openai_client = OpenAI()                                  # uses OPENAI_API_KEY
groq_client   = OpenAI(api_key=os.getenv("GROQ_API_KEY"),
                       base_url="https://api.groq.com/openai/v1")

def ask(client, model, prompt):
    # ① send the prompt to whichever model client was passed in
    r = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}])
    # ② return just the assistant text from the first choice
    return r.choices[0].message.content

def battle(prompt):
    # ① ask OpenAI and Groq the same prompt
    a = ask(openai_client, "gpt-4o-mini", prompt)
    b = ask(groq_client, "llama-3.3-70b-versatile", prompt)
    # ② return both answers so the learner can compare them
    return a, b

def vote(label):
    return f"🗳️ Thanks! You voted: {label}"   # in real apps, save this to a file/DB

# ③ read one prompt to send to both models
prompt = input("Ask both models the same thing: ")
# ④ collect both model answers
a, b = battle(prompt)
# ⑤ show both answers before asking for a vote
print("\n🤖 Model A:\n" + a)
print("\n🤖 Model B:\n" + b)

# ⑥ collect the winner and show a thank-you message
choice = input("\nWhich answer was better? (A/B): ").strip().upper()
print(vote(f"👍 Model {choice}"))

Run it the same way

# install once, then launch
$ pip install openai python-dotenv
$ python arena_app.py

Ask both models the same thing: Explain recursion in 2 sentences.

1. Type a prompt. Run the script, type any question, and press Enter — both models answer.
2. Read both answers, then vote 👍 / 👎. Type A or B for the answer you liked better — just like on arena.ai.
3. Record or share it. A short clip of the battle is perfect for sharing. Stop anytime with Ctrl + C.

⚙️ The sample answers on this page are written examples. In your real arena_app.py, the two answers come from the actual models — and the voting is exactly how arena.ai builds its public leaderboard.

Same 3-step recipe (input → prompt → output), different idea. Pick whichever feels fun — all are beginner-simple:

• ✉️ Email Subject LinerPaste an email → get 5 catchy subject lines.
• 📄 CV → Cover LetterPaste your CV + a job ad → a tailored draft.
• 🏢 Company BrochureGive a company site → a fun marketing brochure.
• 📺 YouTube SummarizerPaste a transcript → the key takeaways.
• 🍳 Recipe FormatterMessy recipe text → clean steps & a shopping list.
• ✈️ Travel Planner"3 days in Goa" → a day-by-day itinerary.

💡 These are drawn from real beginner projects in your course's community folder — proof that "simple + shipped" beats "complex + someday".

You've built an app that answers. The rest of this journey is about apps that do. Here's a taste of three things coming up — no need to master them today, just get excited.

Right now you call the API by hand. The moment you want reusable prompts, multi-step pipelines, memory, or to plug in your own documents, a framework like LangChain saves you re-inventing the wheel. Same idea as today — just with handy connectors:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# ① describe how the website text should be summarized
prompt = ChatPromptTemplate.from_template("Summarize this website: {content}")
# ② choose the chat model that will do the writing
model  = ChatOpenAI(model="gpt-4o-mini")

# ③ pipe the prompt into the model to make a reusable chain
chain = prompt | model            # "|" = send the prompt INTO the model
# ④ run the chain with one page's text
chain.invoke({"content": website_text})   # reuse it for any page!

An agent is an LLM given tools (a calculator, web search, your database) and a loop: it thinks, acts, looks at the result, and repeats until done. Step through one:

For bigger jobs, companies split work across specialists that hand off to each other. This example shows a content team writing a short blog post:

• 🧠 LLMsPredict next token; tokens, temperature, context.
• 🪄 Self-supervisionLearned the internet via fill-in-the-blank.
• 🔌 API callsystem / user / assistant.
• 🎛️ You shippedTwo real AI apps.