How to Build Your First Local AI Agent (For Python Developers)

ollama --version

ollama pull hhao/qwen2.5-coder-tools:7b

ollama run hhao/qwen2.5-coder-tools:7b

mkdir ai-bug-agent
cd ai-bug-agent

python3 -m venv .venv
source .venv/bin/activate
# (On Windows use: .venv\Scripts\activate)

pip install openai

import os

def list_files(directory="."):
    """
    Lists all files in the directory so the Agent knows what exists.
    """
    file_list = []
    # Ignore junk folders to save 'Context Window' (Memory)
    ignore = {'.git', '__pycache__', '.env', 'node_modules', '.venv', '.DS_Store'}

    for root, dirs, files in os.walk(directory):
        # Filter out hidden/ignored directories
        dirs[:] = [d for d in dirs if d not in ignore and not d.startswith('.')]

        for file in files:
            if file.startswith('.'): continue
            file_list.append(os.path.join(root, file))

    return "\n".join(file_list)

def read_file(filepath):
    """
    Reads the content of a specific file.
    Includes a safety limit so we don't crash the model with huge files.
    """
    if not os.path.exists(filepath):
        return f"Error: File '{filepath}' does not exist."

    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
            # Safety: If file is > 20,000 characters, truncate it.
            if len(content) > 20000:
                return (f"Error: File is too large ({len(content)} chars). "
                        "Reading huge files consumes your Context Window too fast.")
            return content
    except Exception as e:
        return f"Error reading file: {str(e)}"

import sys
import json
from openai import OpenAI
from tools import list_files, read_file  # Import our tools

# --- CONFIGURATION ---
# We point the OpenAI client to our LOCAL Ollama server
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Required dummy key
)

# Use the model we downloaded earlier
MODEL_NAME = "hhao/qwen2.5-coder-tools:7b"

# --- SYSTEM PROMPT ---
# This defines the AI's personality and instructions
SYSTEM_PROMPT = """
You are a Senior QA Analyst. You have read-only access to the file system.
Your goal is to investigate the User's Bug Report by tracing code execution.

PROTOCOL:
1. Call `list_files` to map the territory.
2. Call `read_file` on relevant files.
3. Trace imports and function calls logic.
4. When you find the bug, output the FINAL REPORT.

CONSTRAINT:
- Do NOT guess. You must see the code before you blame it.
- If the bug is a "Logic Error" (e.g. truthiness, incorrect operator), explain WHY.

FINAL OUTPUT FORMAT:
Return the final answer in this exact JSON format (no markdown):
{
  "severity": "High/Medium/Low",
  "file": "path/to/buggy_file.py",
  "cause": "Technical explanation...",
  "fix": "Code block of the fix..."
}
"""

def run_agent(user_query):
    # This list is the "Context Window" - the chat history
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_query}
    ]

    print(f"🕵️  Agent starting investigation: '{user_query}'")

    # --- THE AGENT LOOP ---
    # The agent will loop until it decides it's done
    while True:
        # 1. THINK: Ask the LLM what to do next
        response = client.chat.completions.create(
            model=MODEL_NAME,
            messages=messages,
            # We describe our tools to the LLM here
            tools=[
                {
                    "type": "function",
                    "function": {
                        "name": "list_files",
                        "description": "List all files in a directory",
                        "parameters": {"type": "object", "properties": {"directory": {"type": "string"}}}
                    }
                },
                {
                    "type": "function",
                    "function": {
                        "name": "read_file",
                        "description": "Read contents of a file",
                        "parameters": {
                            "type": "object",
                            "properties": {"filepath": {"type": "string"}},
                            "required": ["filepath"]
                        }
                    }
                }
            ]
        )

        # Get the message from the model
        msg = response.choices[0].message

        # 2. ACT: Did the model ask to use a tool?
        if msg.tool_calls:
            # Add the model's "thought" to history so it remembers it asked
            messages.append(msg)

            for tool_call in msg.tool_calls:
                func_name = tool_call.function.name
                # Parse arguments (e.g., {"filepath": "main.py"})
                args = json.loads(tool_call.function.arguments)

                print(f"🤖 Agent is running: {func_name}({args})")

                # Execute the actual Python function
                if func_name == "list_files":
                    result = list_files(args.get("directory", "."))
                elif func_name == "read_file":
                    result = read_file(args["filepath"])
                else:
                    result = "Error: Unknown tool"

                # 3. OBSERVE: Feed the result back to the model
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })

        # 4. FINISH: The model didn't ask for a tool, so it must be done
        else:
            print("-" * 40)
            print("📝 FINAL REPORT:\n")
            print(msg.content)
            break

if __name__ == "__main__":
    # Get the bug report from the command line argument
    if len(sys.argv) > 1:
        query = sys.argv[1]
    else:
        query = "Find the bug in the code."

    run_agent(query)

mkdir test_repo

def check_status(user_id):
    # Returns a dictionary like {"error": "..."} or {"success": True}
    # BUG: In Python, a non-empty dictionary is treated as True!
    result = {"error": "Database connection failed"}

    if result:
        print("✅ Operation Successful!")
    else:
        print("❌ Operation Failed!")

if __name__ == "__main__":
    check_status(1)

python agent.py "In test_repo/main.py, the code prints 'Operation Successful' even when there is an error. Tell me why."