How to Build an AI Agent in Python That Actually Works

#python #programming #tutorial

How to Build an AI Agent in Python That Actually Works

Last updated: July 2026

AI agents are the future of automation. This guide shows you how to build one that's reliable, useful, and doesn't require a PhD in machine learning.

What is an AI Agent?

An AI agent is a program that:

Perceives its environment (reads data, receives inputs)
Makes decisions (using rules, ML, or LLMs)
Takes actions (API calls, file operations, communications)
Learns from results (improves over time)

Simple Rule-Based Agent

Start with a rule-based agent:

class SimpleAgent:
    def __init__(self):
        self.rules = {
            "error": self.handle_error,
            "warning": self.handle_warning,
            "success": self.handle_success,
        }

    def perceive(self, input_data):
        """Parse input and determine type."""
        if "error" in input_data.lower():
            return "error"
        elif "warning" in input_data.lower():
            return "warning"
        return "success"

    def act(self, perception):
        """Execute action based on perception."""
        handler = self.rules.get(perception, self.default_handler)
        return handler()

    def handle_error(self):
        return "Alerting admin and logging error"

    def handle_warning(self):
        return "Logging warning for review"

    def handle_success(self):
        return "No action needed"

    def default_handler(self):
        return "Unknown input, logging for analysis"

LLM-Powered Agent

Use an LLM for more sophisticated decisions:

import requests

class LLMAgent:
    def __init__(self, api_key):
        self.api_key = api_key
        self.history = []

    def decide(self, context):
        """Use LLM to decide what action to take."""
        prompt = f"""Given this context: {context}

What action should I take? Options:
1. send_email
2. create_task
3. update_database
4. notify_user
5. no_action

Respond with just the action name."""

        response = requests.post(
            "https://text.pollinations.ai/",
            json={
                "messages": [{"role": "user", "content": prompt}],
                "model": "openai"
            }
        )

        action = response.text.strip().lower()
        self.history.append({"context": context, "action": action})
        return action

    def execute(self, action, params):
        """Execute the chosen action."""
        actions = {
            "send_email": self.send_email,
            "create_task": self.create_task,
            "update_database": self.update_db,
            "notify_user": self.notify_user,
        }

        handler = actions.get(action)
        if handler:
            return handler(params)
        return "No action taken"

Agent with Memory

Add memory for context retention:

import json
from pathlib import Path

class MemoryAgent:
    def __init__(self, memory_file="agent_memory.json"):
        self.memory_file = Path(memory_file)
        self.memory = self.load_memory()

    def load_memory(self):
        if self.memory_file.exists():
            return json.loads(self.memory_file.read_text())
        return {"short_term": [], "long_term": {}}

    def save_memory(self):
        self.memory_file.write_text(json.dumps(self.memory, indent=2))

    def remember(self, key, value, long_term=False):
        if long_term:
            self.memory["long_term"][key] = value
        else:
            self.memory["short_term"].append({key: value})
            # Keep only last 10 items
            self.memory["short_term"] = self.memory["short_term"][-10:]
        self.save_memory()

    def recall(self, key):
        # Check short-term first
        for item in reversed(self.memory["short_term"]):
            if key in item:
                return item[key]
        # Then long-term
        return self.memory["long_term"].get(key)

Agent with Tools

Give your agent tools to use:

class ToolAgent:
    def __init__(self):
        self.tools = {
            "search": self.search_web,
            "calculate": self.calculate,
            "read_file": self.read_file,
            "write_file": self.write_file,
        }

    def use_tool(self, tool_name, **kwargs):
        if tool_name in self.tools:
            return self.tools[tool_name](**kwargs)
        return f"Unknown tool: {tool_name}"

    def search_web(self, query):
        # Implement web search
        return f"Search results for: {query}"

    def calculate(self, expression):
        try:
            return str(eval(expression))
        except:
            return "Invalid calculation"

    def read_file(self, path):
        try:
            return Path(path).read_text()
        except:
            return "File not found"

    def write_file(self, path, content):
        Path(path).write_text(content)
        return "File written successfully"