Initial setup: starter code app with AI logging hooks

agent.py

@@ -0,0 +1,112 @@
+"""
+Basic agent loop using the Anthropic Claude API.
+Receives user input, calls tools as needed, and returns results.
+"""
+
+import logging
+from anthropic import Anthropic
+from .config import ANTHROPIC_API_KEY, DEFAULT_MODEL, LOG_LEVEL
+from .tools import get_tool_schemas, execute_tool
+
+logging.basicConfig(level=LOG_LEVEL, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+SYSTEM_PROMPT = """You are an intelligent AI assistant.
+You can use the provided tools to complete tasks.
+Think step by step and use tools when necessary."""
+
+
+def create_agent():
+    """Create an agent with the Anthropic client."""
+    if not ANTHROPIC_API_KEY:
+        raise ValueError("ANTHROPIC_API_KEY is not configured. Check your .env file")
+    return Anthropic(api_key=ANTHROPIC_API_KEY)
+
+
+def run_agent_loop(client: Anthropic, user_input: str, max_turns: int = 10) -> str:
+    """
+    Run the agent loop: send message -> receive response -> call tool -> repeat.
+
+    Args:
+        client: Anthropic client
+        user_input: User's question or request
+        max_turns: Maximum number of tool-calling turns
+
+    Returns:
+        The agent's final response
+    """
+    messages = [{"role": "user", "content": user_input}]
+    tools = get_tool_schemas()
+
+    for turn in range(max_turns):
+        logger.info(f"Turn {turn + 1}/{max_turns}")
+
+        response = client.messages.create(
+            model=DEFAULT_MODEL,
+            max_tokens=4096,
+            system=SYSTEM_PROMPT,
+            tools=tools,
+            messages=messages,
+        )
+
+        # If agent stops (no more tool calls)
+        if response.stop_reason == "end_turn":
+            final_text = ""
+            for block in response.content:
+                if hasattr(block, "text"):
+                    final_text += block.text
+            return final_text
+
+        # Handle tool calls
+        tool_results = []
+        has_tool_use = False
+
+        for block in response.content:
+            if block.type == "tool_use":
+                has_tool_use = True
+                logger.info(f"Calling tool: {block.name}({block.input})")
+                result = execute_tool(block.name, block.input)
+                logger.info(f"Result: {result[:200]}")
+                tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": block.id,
+                    "content": result,
+                })
+
+        if not has_tool_use:
+            # No tool calls, return text
+            final_text = ""
+            for block in response.content:
+                if hasattr(block, "text"):
+                    final_text += block.text
+            return final_text
+
+        # Add assistant response and tool results to messages
+        messages.append({"role": "assistant", "content": response.content})
+        messages.append({"role": "user", "content": tool_results})
+
+    return "Agent reached the maximum number of processing turns."
+
+
+def main():
+    """Interactive loop - enter a prompt and receive results."""
+    client = create_agent()
+    print("Agentic App (type 'quit' to exit)")
+    print("-" * 50)
+
+    while True:
+        user_input = input("\nYou: ").strip()
+        if not user_input or user_input.lower() in ("quit", "exit", "q"):
+            print("Bye!")
+            break
+
+        try:
+            response = run_agent_loop(client, user_input)
+            print(f"\nAgent: {response}")
+        except Exception as e:
+            logger.error(f"Error: {e}")
+            print(f"\nError: {e}")
+
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,9 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "claude-sonnet-4-20250514")
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")

tools.py

@@ -0,0 +1,76 @@
+"""
+Tool definitions for the agent.
+Add new tools by creating a function and registering it in the TOOLS dict.
+"""
+
+import httpx
+
+
+def search_web(query: str) -> str:
+    """Search for information on the web (placeholder)."""
+    return f"Search results for: {query}"
+
+
+def calculate(expression: str) -> str:
+    """Evaluate a math expression."""
+    try:
+        result = eval(expression, {"__builtins__": {}})
+        return str(result)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def fetch_url(url: str) -> str:
+    """Fetch content from a URL."""
+    try:
+        resp = httpx.get(url, timeout=10, follow_redirects=True)
+        return resp.text[:2000]
+    except Exception as e:
+        return f"Error: {e}"
+
+
+# Tool registry - the agent uses this dict
+TOOLS = {
+    "search_web": {
+        "fn": search_web,
+        "description": "Search for information on the web",
+        "parameters": {"query": "string"},
+    },
+    "calculate": {
+        "fn": calculate,
+        "description": "Evaluate a math expression",
+        "parameters": {"expression": "string"},
+    },
+    "fetch_url": {
+        "fn": fetch_url,
+        "description": "Fetch content from a URL",
+        "parameters": {"url": "string"},
+    },
+}
+
+
+def get_tool_schemas() -> list[dict]:
+    """Return tool schemas in Anthropic API format."""
+    schemas = []
+    for name, tool in TOOLS.items():
+        schemas.append({
+            "name": name,
+            "description": tool["description"],
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    k: {"type": v, "description": k}
+                    for k, v in tool["parameters"].items()
+                },
+                "required": list(tool["parameters"].keys()),
+            },
+        })
+    return schemas
+
+
+def execute_tool(name: str, args: dict) -> str:
+    """Execute a tool by name."""
+    tool = TOOLS.get(name)
+    if not tool:
+        return f"Tool '{name}' does not exist"
+    return tool["fn"](**args)