AI Agents with LangChain & Autonomous Workflows · Lesson

Building Your First Simple Agent

Follow a step-by-step guide to set up your environment and construct a basic AI agent using LangChain.

Building Your First Simple Agent is a free AI Agents with LangChain & Autonomous Workflows lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Agents with LangChain & Autonomous Workflows learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Build Your First Agent!

Time to build your first AI agent with LangChain — connecting an LLM to basic tools so it can answer your queries intelligently.

Set Up Your Python Environment

First, set up Python 3.9+ and a virtual environment to isolate dependencies. Create one with venv, then activate it before you install anything.

Install LangChain & Dependencies

Now install LangChain and the OpenAI integration. Run the pip command inside your activated virtual environment.

Connect to an LLM

Your agent needs a brain. Initialize ChatOpenAI with your API key stored as the OPENAI_API_KEY environment variable — never hardcode it.

import os
from langchain_openai import ChatOpenAI

def main():
    # In a real setup, ensure OPENAI_API_KEY is set
    # For demonstration, we'll assume it's available
    # os.environ["OPENAI_API_KEY"] = "sk-..." # DON'T hardcode!

    try:
        llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
        print("LLM initialized successfully!")
        # You can test it:
        # response = llm.invoke("Hello, LLM!")
        # print(response.content)
    except Exception as e:
        print(f"Error initializing LLM: {e}")
        print("Please ensure OPENAI_API_KEY is set.")

if __name__ == "__main__":
    main()

Agents Need Tools

An agent is an LLM plus tools — functions or APIs that let it act on the world: search, run code, calculate. Here we give ours a calculator.

import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain

def main():
    # Ensure OPENAI_API_KEY is set
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

    # Create a basic math tool
    llm_math_chain = LLMMathChain.from_llm(llm)
    math_tool = Tool.from_function(
        func=llm_math_chain.run,
        name="Calculator",
        description="Useful for when you need to answer questions about math."
    )
    tools = [math_tool]
    print("Basic math tool created and ready!")

if __name__ == "__main__":
    main()

Choosing Your Agent Type

The agent type defines how it reasons. We'll use create_react_agent — ReAct means Reason and Act: it plans, observes results, then refines.

Combining Components

Now combine the pieces: create_react_agent takes your LLM, tools, and prompt to build the logic, then AgentExecutor wraps it to make it runnable.

import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate

def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    llm_math_chain = LLMMathChain.from_llm(llm)
    math_tool = Tool.from_function(
        func=llm_math_chain.run,
        name="Calculator",
        description="Useful for when you need to answer questions about math."
    )
    tools = [math_tool]

    # Define the prompt for the agent
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful AI assistant. Use tools when necessary."),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}")
    ])

    # Create the agent
    agent = create_react_agent(llm, tools, prompt)

    # Create the agent executor
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    print("Agent assembled and ready for action!")

if __name__ == "__main__":
    main()

Asking Your Agent a Question

With the agent assembled, give it a task via invoke. Ask a math question and watch it reach for its calculator tool to answer.

import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate

def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    llm_math_chain = LLMMathChain.from_llm(llm)
    math_tool = Tool.from_function(
        func=llm_math_chain.run,
        name="Calculator",
        description="Useful for when you need to answer questions about math."
    )
    tools = [math_tool]

    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful AI assistant. Use tools when necessary."),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}")
    ])

    agent = create_react_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    print("Asking the agent: 'What is 123 multiplied by 456?'")
    response = agent_executor.invoke({"input": "What is 123 multiplied by 456?"})
    print("\nAgent's final answer:")
    print(response["output"])

if __name__ == "__main__":
    main()

Understanding the Agent's Response

With verbose=True you see the agent's thought process: Thought, Action, Action Input, Observation, then Final Answer. That transparency is key to debugging.

Your Complete First Agent!

Here's your complete first agent. Set your API key, run it, and try changing the input question to see it reason through different problems.

import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate

def main():
    # 1. Set up your LLM
    # Ensure OPENAI_API_KEY is set as an environment variable
    # os.environ["OPENAI_API_KEY"] = "YOUR_KEY_HERE" # DO NOT hardcode!
    try:
        llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    except Exception as e:
        print(f"Error: {e}. Please ensure OPENAI_API_KEY is set.")
        return

    # 2. Define your tools
    llm_math_chain = LLMMathChain.from_llm(llm)
    math_tool = Tool.from_function(
        func=llm_math_chain.run,
        name="Calculator",
        description="Useful for when you need to answer questions about math."
    )
    tools = [math_tool]

    # 3. Define the agent's prompt
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful AI assistant. Use tools when necessary."),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}")
    ])

    # 4. Create the agent
    agent = create_react_agent(llm, tools, prompt)

    # 5. Create the AgentExecutor
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    # 6. Run the agent
    print("\n--- Running the Agent ---")
    question = "What is the square root of 144 plus 25?"
    print(f"Agent input: '{question}'")
    response = agent_executor.invoke({"input": question})
    print("\n--- Agent's Final Answer ---")
    print(response["output"])

if __name__ == "__main__":
    main()

Agent Components Check

You've seen how to build a basic agent. Which of the following are essential components when constructing a LangChain agent using create_react_agent?

Recap: Your First Agent!

Recap: you built a real agent — set up the environment, connected an LLM, added a tool, assembled it with create_react_agent and AgentExecutor, and watched it think.

Frequently asked questions

Is the “Building Your First Simple Agent” lesson free?

Yes — the full text of “Building Your First Simple Agent” is free to read here on the web, and the AI Agents with LangChain & Autonomous Workflows course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Agents with LangChain & Autonomous Workflows course, upgrade to CoddyKit PRO.

What will I learn in “Building Your First Simple Agent”?

Follow a step-by-step guide to set up your environment and construct a basic AI agent using LangChain. You practise AI Agents with LangChain & Autonomous Workflows with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start AI Agents with LangChain & Autonomous Workflows?

No prior experience is required. AI Agents with LangChain & Autonomous Workflows on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Building Your First Simple Agent” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this AI Agents with LangChain & Autonomous Workflows lesson?

Yes. Every AI Agents with LangChain & Autonomous Workflows lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Understanding AI Agents & LLMs
LangChain Core Components Explained
Building Your First Simple Agent
Giving Agents Memory and Conversation State

← Back to AI Agents with LangChain & Autonomous Workflows