Build Your Own AI Agent: Automating Tasks in 3 Steps

This morning, as I sat at my computer sipping my morning coffee, I thought about automating a report that I had left unfinished the night before. This is a common scenario in project management: repetitive, time-consuming tasks that are simple at their core. Delegating these tasks to AI is a great way to save time and focus on more critical tasks. Building your own AI agent is not as complicated as it seems. Today, I will guide you through the process of using Python, LangChain, and the OpenAI API to start building your AI agent.

In this guide, we will first explain the basic concepts and then create a simple AI agent step by step. Our goal is to build an intelligent system that can automate repetitive tasks. This should be accessible not only to developers but to anyone looking to make their work more efficient. Let’s embark on this automation journey together.

What is an AI Agent and Why Should You Build Your Own?

An AI agent is a software system that can interact with its environment to achieve a specific goal, with capabilities for planning and decision-making. Simply put, it’s an intelligent assistant designed to perform a task on your behalf. These agents can behave like humans and solve complex problems using technologies like natural language understanding (NLU), machine learning (ML), and sometimes large language models (LLM).

There are several reasons to build your own AI agent. First, flexibility. Pre-built solutions may not exactly fit your specific needs. By building your own agent, you can define exactly the functionality, automation level, and integration capabilities you want. Second, learning and experience. This process provides in-depth knowledge about AI, LLMs, and automation technologies. Third, cost-effectiveness. Especially for repetitive and time-consuming tasks, developing an AI agent can be more economical in the long run than doing these tasks manually or using expensive third-party solutions.

Lastly, building your own agent gives you control. You have full oversight over how your data is processed, which tools are used, and how decisions are made. This is critical for businesses sensitive to data privacy and security. Imagine being able to automate tasks like data analysis reports with just a few commands. This saves time for both you and your team.

In summary, building your own AI agent brings automation power to your fingertips. This is not just a technology trend but an opportunity to fundamentally change your work processes.

Setting Up the Environment: Python, LangChain, and OpenAI API

Before we start building our AI agent, we need to set up the necessary software and tools on our system. These steps will form the foundation of our project and ensure a smooth development process. Our key components will be Python, the LangChain library, and an OpenAI API key.

First, ensure Python is installed on your system. Most modern operating systems come with Python pre-installed, but using the latest version is recommended. You can download Python from python.org. During installation, don’t forget to check the “Add Python to PATH” option. Then, creating a virtual environment is a best practice. This isolates the libraries for your project from the global Python installation. Open your terminal and run the following commands:

# Create and enter your project directory
mkdir my-ai-agent
cd my-ai-agent

# Create a virtual environment (using the venv module)
python -m venv venv

# Activate the virtual environment
# For Windows:
# .\venv\Scripts\activate
# For macOS/Linux:
source venv/bin/activate

With the virtual environment active, you’ll see (venv) at the beginning of your terminal prompt. Now, we can install the necessary libraries.

pip install langchain openai python-dotenv

The python-dotenv library helps manage sensitive information like your API key securely. Create a .env file in your project directory and paste your OpenAI API key into it. You can obtain your API key from the OpenAI platform.

# Content of .env file
OPENAI_API_KEY=sk-your-openai-api-key-here

It’s crucial that this file is not added to version control systems like Git. You can ensure this by adding .env to your .gitignore file. Now, we’re ready to work with both Python and LangChain. The security of your API key is the first step in securing your agent.

Step 1: Creating the Basic Agent Structure

In this first step, we’ll use LangChain to create the basic skeleton of a simple AI agent. Our agent’s purpose will be to understand a task given by the user, determine the steps needed to accomplish the task, and execute those steps. This involves creating a “thinking” engine using an LLM and having it interact with specific tools.

LangChain provides various pre-built tools, but we can also define our own custom tools easily. For example, let’s create a tool that reads the content of a text file and returns it in a format the agent can understand. This will enable the agent to perform tasks like document analysis.

Add the following new tools and related updates to your agent.py file:

# agent.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from datetime import datetime
import json

# ... (Previous load_dotenv and LLM definition remain the same) ...

# New Tools
@tool
def read_file_content(filepath: str) -> str:
    """Reads the content of the specified file and returns it as a string."""
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
            # For very long files, we might only take the first 1000 characters
            return content[:1000] if len(content) > 1000 else content
    except FileNotFoundError:
        return f"Error: File not found: {filepath}"
    except Exception as e:
        return f"Error: Problem occurred while reading the file: {e}"

@tool
def write_to_file(filepath: str, content: str) -> str:
    """Writes the given content to the specified file. Creates the file if it doesn't exist."""
    try:
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"Success: Content written to '{filepath}' file."
    except Exception as e:
        return f"Error: Problem occurred while writing to the file: {e}"

@tool
def search_web(query: str) -> str:
    """Performs a web search for the given query and returns the first few results."""
    # This example uses a placeholder. For real implementation, use a web search library (e.g., DuckDuckGo Search API or SerpAPI).
    # Let's simulate it for now:
    results = {
        "artificial intelligence agents": "Artificial intelligence agents are systems capable of decision-making and action planning. They can be developed using frameworks like LangChain.",
        "python file operations": "In Python, files are opened with the open() function, read with read(), and written with write(). The 'with' statement automatically closes resources.",
        "What is LangChain": "LangChain is a framework used for developing LLM-supported applications. Its components include LLMs, prompts, indexes, and agents."
    }
    return results.get(query, "Search results not found.")

# Combine all tools
tools = [get_current_time, read_file_content, write_to_file, search_web]

# Update the prompt template to include the list of tools
# (This allows the agent to understand the new tools)
prompt_template = """
You are a helpful AI assistant. Your task is to fulfill the user's request by using the available tools and returning the result.

Available Tools:
{tools}

Conversation History:
{chat_history}

User Request:
{input}

{agent_scratchpad}
"""

prompt = ChatPromptTemplate.from_template(prompt_template)

# Create the agent using the LLM and tools
agent = create_tool_calling_agent(llm, tools, prompt)

# Initialize the AgentExecutor to run the agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Test the agent
if __name__ == "__main__":
    # Test 1: Get the current time
    user_input_1 = "What's the current time?"
    print(f"User request: {user_input_1}")
    response_1 = agent_executor.invoke({"input": user_input_1})
    print(f"Agent's response: {response_1['output']}")

    # Test 2: Create a file and write to it
    file_path_write = "my_notes.txt"
    file_content_write = "This is the first note created by my AI agent using LangChain.\nAutomation is great!"
    user_input_2 = f"Write the following content to '{file_path_write}' file: {file_content_write}"
    print(f"\nUser request: {user_input_2}")
    response_2 = agent_executor.invoke({"input": user_input_2})
    print(f"Agent's response: {response_2['output']}")

    # Test 3: Read a file
    user_input_3 = f"Read the content of '{file_path_write}' file."
    print(f"\nUser request: {user_input_3}")
    response_3 = agent_executor.invoke({"input": user_input_3})
    print(f"Agent's response: {response_3['output']}")

    # Test 4: Web search simulation
    user_input_4 = "Tell me about LangChain."
    print(f"\nUser request: {user_input_4}")
    response_4 = agent_executor.invoke({"input": user_input_4})
    print(f"Agent's response: {response_4['output']}")

    # Test 5: Task requiring multiple steps
    # First, create a file and then read its content
    file_path_complex = "complex_task.txt"
    complex_content = "This content is created for a complex task."
    user_input_5 = f"Write '{complex_content}' to '{file_path_complex}' file, then read the file's content."
    print(f"\nUser request: {user_input_5}")
    response_5 = agent_executor.invoke({"input": user_input_5})
    print(f"Agent's response: {response_5['output']}")

This update allows our agent to:

• read_file_content(filepath: str): Read the content of a file specified by its path. It includes error management (if the file is not found or there’s a reading error).
• write_to_file(filepath: str, content: str): Write given content to a specified file. If the file doesn’t exist, it’s created.
• search_web(query: str): Perform a web search for a given query. This example is simulated with a simple dictionary lookup. For a real application, you would integrate it with a web search library like DuckDuckGo Search API or SerpAPI.

We’ve updated the if __name__ == "__main__": block to test these new tools with various scenarios. You’ll see the agent successfully performing single-step (getting the time, creating a file) and multi-step tasks (creating a file and then reading it). The verbose=True setting allows you to see which tools the agent uses and in what order, helping with debugging.

For instance, when you ask the agent to “Write to a file and then read it,” it will first use the write_to_file tool and then the read_file_content tool. This demonstrates the LLM’s “thinking” and “planning” capability.

Step 3: Using the Agent for Automated Tasks

Now that we have our basic AI agent and have enhanced it with file operations and web search capabilities, it’s time to use it for real-world automation scenarios. Automated tasks aim to perform repetitive jobs without human intervention. This can save time and resources in areas like report generation, data collection, and system updates.

One simple way to use our agent for automated tasks is by scripting it to run at certain times or events. For example, we could create a script that every day at a certain time fetches data from a website and saves it to a file. We can use the schedule module or the operating system’s scheduler (cron job, Task Scheduler) for this.

Below is a simple example scenario where every day at 9:00 AM, our agent automatically searches for news headlines and saves them to a daily_news_report.txt file.

First, let’s make our search_web function more realistic by integrating it with a real web search library. We’ll use the duckduckgo_search library for this. If you haven’t installed it, you can do so with pip install duckduckgo-search.

# agent.py (update to search_web function)
# ...
from duckduckgo_search import DDGS # Add this line

@tool
def search_web(query: str) -> str:
    """Performs a web search for the given query and returns the first few results."""
    try:
        with DDGS() as ddgs:
            results = [r['title'] + ": " + r['snippet'] for r in ddgs.text(query, max_results=5)]
            if not results:
                return "Search results not found."
            return "\n".join(results)
    except Exception as e:
        return f"Web search error: {e}"
# ...

Now, let’s create a new script, auto_task.py, to automate this daily task:

# auto_task.py
import schedule
import time
from agent import agent_executor # Import agent_executor from agent.py

def daily_report_task():
    """Automated task to run every day."""
    print("Starting automated report task...")

    # Task 1: Fetch current tech news
    query = "latest artificial intelligence news"
    print(f"Performing web search: '{query}'")
    try:
        search_result = agent_executor.invoke({"input": f"Tell me about {query}."})
        news_content = search_result['output']
        
        # Save the news to a file
        file_path = "daily_news_report.txt"
        write_success_message = agent_executor.invoke({
            "input": f"Write the following content to '{file_path}' file: \n\n{news_content}"
        })
        print(f"News saved to file: {write_success_message['output']}")

    except Exception as e:
        print(f"Error during automated task: {e}")

    print("Automated report task completed.")

# Schedule the task to run every day at 09:00
schedule.every().day.at("09:00").do(daily_report_task)

print("Automated task scheduler started. Runs daily at 09:00.")

while True:
    schedule.run_pending()
    time.sleep(1)

Running this auto_task.py script will have our agent automatically search for the latest AI news every day at 9:00 AM and save the results to a daily_news_report.txt file.

This simple example demonstrates the potential of AI agents in automation. For more complex scenarios:

• API Integrations: Integrate your agent with other services’ APIs (e.g., sending emails, querying databases) to expand the automation scope.
• Conditional Logic: Have the agent perform different actions based on its output. For example, if a report is missing, it could send an automatic email to the relevant person.
• Error Management and Notifications: Implement mechanisms for the agent to notify you if it fails or to retry the task.
• Orchestration Tools: For larger-scale automations, consider integrating with workflow orchestration tools like airflow or prefect.

These steps allow you to build your own simple but powerful AI agent and start automating repetitive tasks. Remember, the key is well-defined tools that the agent can understand and good prompt engineering.

Conclusion: Discover Your Automation Power

We’ve reached the end of our journey to build our own AI agent. This guide has shown us how to create a basic agent structure using Python, LangChain, and the OpenAI API, enhance it with file operations and web search capabilities, and finally use it for automated tasks. This process demonstrates how AI and automation can be integrated into daily workflows.

In summary, an AI agent is an intelligent software that interacts with its environment to achieve a goal. Building your own agent provides flexibility, a learning opportunity, and cost advantages. Setting up the environment involves installing Python, LangChain, and the OpenAI API. Then, defining tools using the @tool decorator and careful prompt engineering form the agent’s logic. Finally, integrating these agents with schedulers like schedule enables automation of repetitive tasks.

The examples in this guide are just the beginning of what AI agents can do. You can expand their capabilities by adding more complex tools (database interactions, other APIs), advanced planning algorithms, and long-term memory mechanisms. Building your own AI agent is not just a technology project; it’s a strategic step towards making your work more efficient, intelligent, and less labor-intensive. Discover your automation power now!