Lessons · Coding · beginner · Tech With Tim

Build an AI Agent From Scratch in Python - Tutorial for Beginners

The video “Build an AI Agent From Scratch in Python - Tutorial for Beginners” by Tech With Tim as 9 lessons, with the idea explained, the code from the screen, steps to try in the practice terminal, practice problems with solutions and a quiz that leads back to the moment.

9lessons
17pieces of code
20exercises
30questions
34min of video
Open the lessons →Lesson 1 is free · Beyond Pass opens all
Build an AI Agent From Scratch in Python - Tutorial for Beginners, video by Tech With Tim▶ 34:19 · Tech With Tim
123456789
0:009 lessons across the whole video34:19

You will be able to

  • Create a Python virtual environment and install LangChain dependencies from a requirements file
  • Connect a chat model from OpenAI or Anthropic using API keys stored in a .env file
  • Define a Pydantic schema and a parser so the LLM returns structured, predictable output
  • Build a tool-calling agent with an AgentExecutor and run it from user input
  • Wrap a DuckDuckGo search, a Wikipedia lookup, and a custom Python function as agent tools
  • Handle parsing errors and save structured agent results to a text file

Good to know first

  • Python 3.10 or newer installed, with basic Python syntax such as classes and functions
  • Comfort running commands in a terminal and using a code editor such as VS Code
  • Basic understanding of what an LLM API is and how to call it
  • An OpenAI or Anthropic account with an API key

Syllabus

9 lessons and a final project

  1. 1

    Demo of the finished research assistant Free

    0:00–1:352 min of video

    You see the finished AI research assistant run from the terminal: you type a topic, the agent searches Wikipedia, saves a summary to a file, and prints a structured report. This lesson shows what the finished agent does so you know the goal before you build it.

    4 build steps2 exercises3 questions
  2. 2

    Setting up the project folder and virtual environment Beyond Pass

    1:35–6:555 min of video

    You will create a project folder, list the Python packages the agent needs in a requirements.txt file, and set up an isolated virtual environment (venv) to install them into. By the end, your terminal shows the (venv) prefix and the packages are installed.

    5 code5 build steps2 exercises3 questions
  3. 3

    Choosing an LLM and Loading API Keys Beyond Pass

    6:55–12:306 min of video

    You will set up main.py to create a language model (either OpenAI's or Anthropic's Claude), store your secret API key safely in a .env file, and run a first test call. The chapter shows how each piece connects so your agent can talk to an AI model.

    2 code5 build steps2 exercises3 questions
  4. 4

    Defining a Pydantic schema and prompt template Beyond Pass

    12:30–16:404 min of video

    You will define a Pydantic class that describes the shape of the answer you want from the LLM, and build a prompt template that tells the model to follow that shape. Together they make the model's output predictable enough for your code to use as a normal Python object.

    1 code4 build steps3 exercises3 questions
  5. 5

    Creating the tool-calling agent and executor Beyond Pass

    16:40–20:574 min of video

    You will fill in the prompt's format instructions with partial(), build a tool-calling agent with create_tool_calling_agent, and run it through an AgentExecutor to get a raw response. This is the point where the pieces from earlier (LLM, parser, prompt) become one working agent.

    1 code5 build steps2 exercises4 questions
  6. 6

    Parsing agent output and handling errors Beyond Pass

    20:57–23:373 min of video

    You will pull the text out of the agent's raw response, turn it into a typed Python object with a parser, and wrap that step in try/except so a bad model reply produces a readable error instead of a crash. You will then read fields like topic straight off the result.

    2 code3 build steps3 exercises3 questions
  7. 7

    Giving your agent a search tool (DuckDuckGo) Beyond Pass

    23:37–28:535 min of video

    You will learn what a tool is for an AI agent and how to wrap a free DuckDuckGo search as a named, described Tool the agent can call. You will then hand that tool to the agent and ask it a question that needs live web search.

    2 code4 build steps2 exercises4 questions
  8. 8

    Adding the Wikipedia tool to your agent Beyond Pass

    28:53–30:552 min of video

    You learn how to create a Wikipedia tool with WikipediaAPIWrapper and WikipediaQueryRun, configure how much it returns, and hand it to the agent's tools list. You also see how the agent chooses between the search tool and the Wikipedia tool.

    2 code5 build steps2 exercises3 questions
  9. 9

    Writing a custom save-to-file tool Beyond Pass

    30:55–34:193 min of video

    You learn how any ordinary Python function can become a tool an agent can call, by typing its parameters and wrapping it with a name and description. You then give the agent the new save tool and watch it research a topic and write the result to a file.

    2 code5 build steps2 exercises4 questions

Final project

Build Your Own Research Assistant Agent

Build a terminal research assistant from scratch. It takes a topic, uses a web search tool, a Wikipedia tool and a custom save-to-file tool, and prints a structured report. This ties together the environment setup, LLM connection, Pydantic parsing, tools and error handling from the course.

Its 7 tasks open with Beyond Pass.

Free preview · Lesson 1 in full

Demo of the finished research assistant

You see the finished AI research assistant run from the terminal: you type a topic, the agent searches Wikipedia, saves a summary to a file, and prints a structured report. This lesson shows what the finished agent does so you know the goal before you build it.

0:00 to 1:35 in the video

Practice terminal

Type the lesson's commands, break things, and see why.

Scratchpad

Draw and write next to the video.

The idea

This chapter is a preview. Tech With Tim shows the finished project before building it, so you know what you are aiming for. The project is a research assistant: a program that takes a question from you, goes and looks things up, and gives back an organised answer.

The program starts by asking What should I research? You type a request in plain English, for example: Tell me about LangChain and its applications and save it to a file. The request does not name any tools. The agent has to decide for itself which tools to use.

While it works, the terminal shows the agent's steps. The line Entering new AgentExecutor chain... means the agent has started. Then it prints Invoking: wikipedia with a query, which means it chose the Wikipedia tool and gave it a search term such as LangChain framework. Later it calls saveTextToFile to write the result to disk. You can also turn this step-by-step view off if you only want the final answer.

The final output is structured. It has a Topic, a Summary, the Sources it used, and the Tools Used. The video also shows that a file called research_output.txt appears in the project folder. It holds the research text, a timestamp, and the content, so the result is saved for later.

The key idea is this: an agent is a language model (such as Claude or GPT) that can call tools you give it, read their results, and keep going until it has an answer. The demo is small, but the same pattern can support many more tools.

Key points

  • The agent takes a plain-English request and decides which tools to use by itself. 0:26
  • Invoking: wikipedia shows the agent calling a tool with a search query. 0:48
  • The final answer is structured: Topic, Summary, Sources and Tools Used. 1:06
  • The agent also saves its result to a text file with a timestamp, using a custom saveTextToFile tool. 1:12
  • A tool is a function you give the model; the model chooses when and how to call it. 1:30

Build along in the practice terminal

  1. Open a terminal in your project folder (the folder that holds main.py) and run the program with python main.py. 
    $ python main.py
What should I research?
    You should see: The program asks you what to research and waits for your text.
  2. Type a research request and press Enter. Ask for a file to be saved so the save tool is used. You should see: The agent starts working and prints its first step.
  3. Watch for the Invoking line that names a tool, such as wikipedia, and read the query it sends. You should see: You can see which tool the agent picked and what it searched for.
  4. When the chain finishes, read the structured report: Topic, Summary, Sources and Tools Used. You should see: You get a clean report and a research_output.txt file appears in your project folder.

Practice

Explain Solution checked

In your own words, explain what an AI agent does that a plain chatbot answer does not.

Hint

Think about tools: what can the agent do on its own that a model answering from memory cannot?

Solution
  1. A plain model answers from what it already knows.
  2. An agent can call tools (such as a Wikipedia search or a save-to-file function) during its work.
  3. It reads the tool results and decides the next step until it can give a final answer.

An agent can call tools like searching Wikipedia or saving a file, read the results, and decide what to do next, while a plain chatbot only answers from its own knowledge.

Do it Solution checked

Run the demo or any example request yourself, then list the tools the agent used and the file it created (if any).

Hint

Look for lines beginning with Invoking and at the Tools Used line at the end.

Solution
  1. Start the program and type a request that needs research.
  2. Note each Invoking line and the tool name.
  3. Check the Tools Used line and your project folder for a new text file.

A list of the tools invoked and the output file created.

On your scratchpad

Draw a simple box diagram: You (question) -> Agent (language model) -> Tools (Wikipedia, save file) -> Final report. Label the arrows with what passes along each one.

Quiz

  1. What does the line 'Invoking: wikipedia with {query: LangChain framework}' show?

    1. The agent has finished and is closing the program
    2. The agent chose the Wikipedia tool and sent it a search query
    3. The file research_output.txt has been deleted
    4. The language model has crashed
    Show the answer

    B. The agent chose the Wikipedia tool and sent it a search query · Invoking means the agent called a tool. Here it called wikipedia with the query LangChain framework. (The video shows this at 0:53 and 0:48.)

    0:53 watch the moment

  2. Which of these is part of the final structured output in the demo?

    1. A Topic, Summary, Sources and Tools Used
    2. A list of Python package versions
    3. The source code of main.py
    4. A graph of response times
    Show the answer

    A. A Topic, Summary, Sources and Tools Used · The final report has a Topic, a Summary, the Sources it used and the Tools Used. (Shown at 1:06.)

    1:06 watch the moment

  3. Where does the saved research end up?

    1. Only in the terminal history, which is then lost
    2. In a text file, research_output.txt, in the project folder
    3. On a remote server owned by the video's author
    4. In the Python interpreter's memory only
    Show the answer

    B. In a text file, research_output.txt, in the project folder · The saveTextToFile tool writes the content, timestamp included, to research_output.txt on the left-hand side of the editor. (Shown at 1:12.)

    1:12 watch the moment

Open lesson 1, with the video →

Lessons 2–9 and the final project

They open with Beyond Pass: every lesson of every course, in full. One payment: $14.99 for 90 days or $29 for a year. No subscription.

Get Beyond Pass →Start lesson 1 free

Made by Beyond from the video “Build an AI Agent From Scratch in Python - Tutorial for Beginners” by Tech With Tim. The video plays in YouTube's own player. Watch it on YouTube · All lessons