Module 2: Environment Setup & API Configuration

Before building AI agents, you need a properly configured development environment. This module walks you through every step — from installing Python to verifying your first API connection. By the end, you will have a working project scaffold ready for the rest of this tutorial series.

Here is what you need before starting:

• Python 3.10+ installed — we recommend Python 3.11 or 3.12 for the best compatibility with modern AI libraries
• An OpenAI API key from platform.openai.com
• An Anthropic API key from console.anthropic.com
• A code editor — VS Code is recommended for its excellent Python support and integrated terminal
• Basic Python knowledge — functions, classes, dictionaries, and working with packages
• A terminal / command line — you should be comfortable running commands

Checking Your Python Version

Open a terminal and verify your Python installation:

# Check Python version (must be 3.10 or higher)
python --version
# Output: Python 3.12.4

# On some systems, you may need to use python3
python3 --version

If you do not have Python installed, download it from python.org. On macOS, you can also use brew install python. On Ubuntu/Debian, use sudo apt install python3.

We strongly recommend using a virtual environment to isolate your project dependencies. This prevents version conflicts between different Python projects on your machine.

Create a Virtual Environment

# Create project directory
mkdir ai-agent-tutorial
cd ai-agent-tutorial

# Create a virtual environment
python -m venv venv

# Activate it (macOS / Linux)
source venv/bin/activate

# Activate it (Windows)
venv\Scripts\activate

# You should see (venv) in your terminal prompt

Install the Required Packages

# Install all dependencies at once
pip install openai anthropic python-dotenv

# Verify installation
pip list | grep -E "openai|anthropic|dotenv"

This installs three packages:

A well-organised project structure will save you headaches as your agent grows in complexity. Here is the structure we will build throughout this tutorial series:

ai-agent-tutorial/
├── .env                 # API keys (NEVER commit this file!)
├── .gitignore           # Must include .env
├── requirements.txt     # Pinned dependencies
├── config.py            # Centralised configuration
├── agent_openai.py      # OpenAI-based agent implementation
├── agent_anthropic.py   # Anthropic-based agent implementation
├── tools.py             # Tool definitions and implementations
├── memory.py            # Memory management (short + long term)
├── evaluator.py         # Agent evaluation and testing
└── main.py              # Entry point

Each file has a clear responsibility. This separation of concerns makes it easy to swap components — for example, switching from OpenAI to Anthropic by changing one import.

Create the .gitignore File

If you are using Git (you should be), create a .gitignore immediately to prevent accidentally committing sensitive files:

# .gitignore
.env
venv/
__pycache__/
*.pyc
.DS_Store

API keys are how OpenAI and Anthropic identify and bill your account. They are secrets that must never appear in your source code, commit history, or public repositories.

Getting Your API Keys

OpenAI: Go to platform.openai.com/api-keys, click "Create new secret key", give it a name, and copy the key. You will only see it once.

Anthropic: Go to console.anthropic.com/settings/keys, click "Create Key", name it, and copy. Same rule — you will only see it once.

Store Keys in a .env File

Create a .env file in your project root. This file is loaded at runtime but never committed to version control:

# .env
OPENAI_API_KEY=sk-proj-your-key-here
ANTHROPIC_API_KEY=sk-ant-your-key-here

Alternative: System Environment Variables

For production deployments, you may prefer to set keys as system environment variables rather than using a .env file:

# macOS / Linux (add to ~/.bashrc or ~/.zshrc for persistence)
export OPENAI_API_KEY="sk-proj-your-key-here"
export ANTHROPIC_API_KEY="sk-ant-your-key-here"

# Windows PowerShell
$env:OPENAI_API_KEY="sk-proj-your-key-here"
$env:ANTHROPIC_API_KEY="sk-ant-your-key-here"

Now let us write a configuration module that loads and validates your API keys. This pattern ensures you catch missing keys early, before any API calls are attempted.

Basic Key Loading

# config.py
import os
from dotenv import load_dotenv

# Load variables from .env file into environment
load_dotenv()

# Read keys from environment
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

# Validate - fail fast if keys are missing
assert OPENAI_API_KEY, "Missing OPENAI_API_KEY in .env file"
assert ANTHROPIC_API_KEY, "Missing ANTHROPIC_API_KEY in .env file"

print("API keys loaded successfully.")

Verifying Your Connection

Before moving to the next module, let us verify that your keys work by making a minimal API call to each provider:

# verify_setup.py
import os
from dotenv import load_dotenv
from openai import OpenAI
import anthropic

load_dotenv()

# --- Test OpenAI ---
print("Testing OpenAI connection...")
oai_client = OpenAI()  # Automatically reads OPENAI_API_KEY
response = oai_client.chat.completions.create(
    model="gpt-4o-mini",   # Use the cheapest model for testing
    messages=[{"role": "user", "content": "Say 'hello' and nothing else."}],
    max_tokens=10
)
print(f"  OpenAI response: {response.choices[0].message.content}")

# --- Test Anthropic ---
print("Testing Anthropic connection...")
ant_client = anthropic.Anthropic()  # Automatically reads ANTHROPIC_API_KEY
message = ant_client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=10,
    messages=[{"role": "user", "content": "Say 'hello' and nothing else."}]
)
print(f"  Anthropic response: {message.content[0].text}")

print("\nAll connections verified! Your environment is ready.")

Run this file:

python verify_setup.py
# Expected output:
# Testing OpenAI connection...
#   OpenAI response: hello
# Testing Anthropic connection...
#   Anthropic response: hello
# All connections verified! Your environment is ready.

Troubleshooting Common Errors

A Robust Configuration Module

For a production-quality setup, use a configuration class that handles multiple environments (development, testing, production) and provides sensible defaults:

# config.py - production-quality configuration
import os
from dataclasses import dataclass
from dotenv import load_dotenv

load_dotenv()

@dataclass
class Config:
    """Centralised configuration for the AI agent project."""
    openai_api_key: str = ""
    anthropic_api_key: str = ""
    default_provider: str = "anthropic"  # or "openai"
    default_model: str = "claude-sonnet-4-20250514"
    max_tokens: int = 1024
    temperature: float = 0.0
    max_agent_steps: int = 10
    log_file: str = "agent_log.jsonl"

    @classmethod
    def from_env(cls) -> "Config":
        """Load configuration from environment variables."""
        return cls(
            openai_api_key=os.getenv("OPENAI_API_KEY", ""),
            anthropic_api_key=os.getenv("ANTHROPIC_API_KEY", ""),
            default_provider=os.getenv("DEFAULT_PROVIDER", "anthropic"),
            max_agent_steps=int(os.getenv("MAX_AGENT_STEPS", "10")),
        )

    def validate(self) -> list[str]:
        """Return a list of configuration errors (empty = all good)."""
        errors = []
        if not self.openai_api_key:
            errors.append("OPENAI_API_KEY is not set")
        if not self.anthropic_api_key:
            errors.append("ANTHROPIC_API_KEY is not set")
        return errors

# Usage
config = Config.from_env()
errors = config.validate()
if errors:
    print("Configuration errors:")
    for e in errors:
        print(f"  - {e}")
else:
    print("Configuration OK")

VS Code Recommended Extensions

If you are using VS Code, install these extensions for the best development experience with AI agent projects: