Build an AI agent that searches the web for you

In this workshop

1. 1Why a chatbot alone is not enough Everyone
2. 2How the agent loop works Everyone
3. 3Words you will hear Everyone
4. 4Where businesses use agents Everyone
5. 5What you need Developers
6. 6Build it: 9 steps Developers
7. 7Check the answer, not just the code Everyone
8. 8Errors we hit and how we fixed them Developers
9. 9Under the hood: ReAct vs tool calling Developers
10. 10Limits, cost and safety Everyone
11. 11Practice tasks and quiz Everyone

This is the exact flow of the agent we build. Each step shows what happens in plain words and, in green, the matching piece of code.

The pattern stays the same in every case. Only the tools change. That is why learning this one small agent is a big step.

• Python 3.10 or newer. The original notebook ran on Python 3.14 on Windows.
• A Gemini API key from Google AI Studio. The free tier is enough for this workshop.
• VS Code with the Jupyter extension, or plain Jupyter Notebook.
• No search API key: DuckDuckGo search is free.

1. Create a project and install packages

   PowerShellCopy

   # Windows (PowerShell) - macOS/Linux: use "python3" and "source .venv/bin/activate"
   mkdir ai_workshop; cd ai_workshop
   python -m venv .venv
   .venv\Scripts\activate
   
   pip install -U langchain langgraph langchain-core langchain-community langchain-google-genai ddgs python-dotenv jupyter

   A virtual environment keeps this project's packages separate from everything else on your computer. ddgs is the current name of the DuckDuckGo search package; the older duckduckgo-search name is being replaced.

2. Store your API key safely

   .envCopy

   # File name: .env   (same folder as your notebook - never commit this file to GitHub)
   GOOGLE_API_KEY=paste-your-key-from-google-ai-studio-here

   Keeping the key in a .env file means it never appears in your code, screenshots or GitHub. Add .env to .gitignore.

3. Check that Python can see the key

   PythonCopy

   import os
   from dotenv import load_dotenv
   
   load_dotenv()                                   # reads .env into environment variables
   api_key = os.getenv("GOOGLE_API_KEY")
   
   print("API key loaded:", bool(api_key))         # True = good. Never print the key itself.

   If this prints False, every later step fails with "API key required". Fix it here first.

4. Ask Google which models you can use

   PythonCopy

   from google import genai
   import os
   
   client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
   
   # Model names change often. Ask Google which ones YOUR key can use today.
   for model in client.models.list():
       print(model.name)

   Model names change every few months and old ones get switched off. In our run, gemini-2.5-flash returned "no longer available to new users", so we listed the models and picked one from the list.

5. Talk to Gemini once, without tools

   PythonCopy

   from langchain_google_genai import ChatGoogleGenerativeAI
   
   llm = ChatGoogleGenerativeAI(
       model="gemini-3.5-flash-lite",   # pick a name from the list in step 4
       timeout=60,                      # give up after 60 s instead of hanging
       max_retries=3,                   # retry temporary errors such as 503 "high demand"
   )
   
   response = llm.invoke("Say hello in one short sentence.")
   
   # Newer Gemini models return a LIST of content blocks, not a plain string.
   def text_of(content):
       if isinstance(content, list):
           return "".join(part.get("text", "") for part in content if isinstance(part, dict))
       return content
   
   print(text_of(response.content))

   This proves the key, network and model all work before you add more moving parts. The text_of helper handles a real surprise from our run: the newer model returned a list of content blocks instead of a plain string.

6. Give the agent a tool: web search

   PythonCopy

   from langchain_community.tools import DuckDuckGoSearchRun
   
   search = DuckDuckGoSearchRun()        # free web search, no API key needed
   tools = [search]
   
   print("Tool ready:", search.name)     # -> duckduckgo_search
   print(search.description)             # this text is what Gemini reads to decide WHEN to use it

   The tool's name and description are sent to Gemini. That is all Gemini knows about the tool, so a clear description directly improves when and how the agent uses it.

7. Create the agent and ask your question

   PythonCopy

   from langchain.agents import create_agent
   
   agent = create_agent(
       model=llm,
       tools=tools,
   )
   
   question = ("What is the latest iPhone model and its price in USD? "
               "Give me the price in UK currency.")
   
   response = agent.invoke({
       "messages": [{"role": "user", "content": question}]
   })
   
   print(text_of(response["messages"][-1].content))

   Output from our run:

   Output

   The latest flagship smartphone lineup from Apple is the iPhone 16 series
   (including the iPhone 16, iPhone 16 Plus, iPhone 16 Pro, and iPhone 16 Pro Max).
   
   Taking the base model (iPhone 16 with 128GB of storage) as the standard reference:
   
   * Price in USD: $799 (US prices do not include state/local sales tax)
   * Price in UK Currency (GBP): £799 (UK prices automatically include 20% VAT)
   
   (If you are looking at the entry-level Pro model, the iPhone 16 Pro starts at $999 USD / £999 GBP).

8. Look inside the loop

   PythonCopy

   # Look inside the loop: every step the agent took is in response["messages"]
   for msg in response["messages"]:
       kind = type(msg).__name__                     # HumanMessage / AIMessage / ToolMessage
       if kind == "AIMessage" and msg.tool_calls:
           for call in msg.tool_calls:
               print(f"🧠 Gemini decided to call {call['name']} with {call['args']}")
       elif kind == "ToolMessage":
           print(f"🔎 Tool returned: {str(msg.content)[:200]}...")
       elif kind == "AIMessage":
           print(f"✅ Final answer: {text_of(msg.content)[:200]}...")
       else:
           print(f"🙋 You asked: {msg.content}")

   The response holds every message in the loop: your question, each tool call Gemini asked for, each search result, and the final answer. Printing them shows you whether the agent really searched or answered from memory. This matters, as section 7 explains.

9. Make the agent more reliable

   PythonCopy

   from datetime import date
   from langchain.agents import create_agent
   from langchain.tools import tool
   
   @tool
   def usd_to_gbp(amount_usd: float, rate: float) -> str:
       """Convert US dollars to British pounds. Always find today's USD->GBP rate with web search first."""
       return f"{amount_usd} USD = {amount_usd * rate:.2f} GBP (rate {rate})"
   
   agent = create_agent(
       model=llm,
       tools=[search, usd_to_gbp],
       system_prompt=(
           f"Today is {date.today():%d %B %Y}. "
           "For anything that changes over time (products, prices, exchange rates, news) "
           "you MUST use web search instead of your own memory. "
           "Name the sources you used. If the search fails, say so."
       ),
   )

   Two upgrades. A system prompt tells the agent today's date and forces it to search for anything time-sensitive. A second custom tool, built with @tool, does the currency maths exactly, so the model does not guess a rate. The function's docstring becomes the tool description Gemini reads.

Every one of these happened while building this workshop. Expect to meet some of them.

Try these next

1. Easy: ask "What is the weather in Mumbai today?" and use step 8 to confirm a search happened.
2. Easy: change the system prompt so the agent always answers in Hindi.
3. Medium: add a @tool that returns today's date and time, and remove the date from the system prompt.
4. Medium: wrap the search tool so it catches errors and returns "search unavailable" instead of crashing.
5. Stretch: add memory with a LangGraph checkpointer and a thread_id, so follow-up questions like "and in euros?" work.
6. Stretch: turn it into a small web app with Streamlit or Gradio.

Quick quiz

Summary