How to Build an AI Agent: From Scratch to Production

import os
import json
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", "your-api-key"))

# 1. Define our tool functions (The agent's "hands")
def calculate(expression: str) -> str:
    """Safely evaluates a basic mathematical expression."""
    try:
        # For production use ast.literal_eval or math parsers
        allowed = {"__builtins__": None}
        return str(eval(expression, allowed, {}))
    except Exception as e:
        return f"Error evaluating: {e}"

def search_product_db(query: str) -> str:
    """Mock inventory database lookup."""
    catalog = {
        "laptop": {"name": "ProBook 16", "price": 1299, "stock": 4},
        "monitor": {"name": "4K UltraDisplay", "price": 499, "stock": 12},
        "keyboard": {"name": "Mechanical Pro", "price": 129, "stock": 0}
    }
    for item, data in catalog.items():
        if item in query.lower():
            return json.dumps(data)
    return json.dumps({"error": "Item not found in catalog"})

TOOL_REGISTRY = {
    "calculate": calculate,
    "search_product_db": search_product_db
}

# 2. Declare tool JSON schemas for the LLM
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Evaluate basic arithmetic expressions.",
            "parameters": {
                "type": "object",
                "properties": {"expression": {"type": "string", "description": "e.g. 1299 * 3 * 0.9"}},
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_product_db",
            "description": "Look up product pricing and stock inventory.",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string", "description": "Product keyword e.g. laptop"}},
                "required": ["query"]
            }
        }
    }
]

# 3. The Autonomous Agent Execution Loop
def run_agent(user_goal: str, max_iterations: int = 6):
    messages = [
        {"role": "system", "content": "You are a helpful inventory and sales agent. Use tools to verify facts before answering."},
        {"role": "user", "content": user_goal}
    ]

    for step in range(max_iterations):
        print(f"\n[Step {step + 1}] Thinking...")
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        # If model decides it has the final answer, we are done!
        if not msg.tool_calls:
            print("\n[Final Answer]:")
            return msg.content

        # Model decided to call one or more tools
        for tool_call in msg.tool_calls:
            fn_name = tool_call.function.name
            args = json.loads(tool_call.function.arguments)
            print(f"  ⚡ Action: {fn_name}({args})")

            # Execute Python tool
            fn = TOOL_REGISTRY.get(fn_name)
            result = fn(**args) if fn else f"Error: Tool {fn_name} not found"
            print(f"  🔍 Observation: {result}")

            # Return tool observation back to conversation history
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "Agent aborted: Reached maximum iterations."

# Run the Agent!
if __name__ == "__main__":
    prompt = "What is the total cost of buying 3 laptops with a 10% discount, and are they in stock?"
    answer = run_agent(prompt)
    print(answer)