M00 — Setup & Three Clients

Three companies, three SDKs, one identical idea. In this module you'll install the Anthropic (Claude), Google (Gemini), and OpenAI (GPT) SDKs, get an API key for each, and send the exact same "Hello" to all three — so you can see, side by side, how alike they really are.

Learning Objectives

• Install and import all three official SDKs in Python and Node.js, and know the exact package names
• Get an API key from each provider and wire it in through the correct environment variableA named value your program reads from the operating system instead of hard-coding it in source. Keeps secrets like API keys out of your code and out of version control.
• Send an identical one-shot message through the Anthropic, Gemini, and OpenAI SDKs and read the reply
• Recognize the universal agent pipeline that every provider implements, just with different names
• Pick a sensible default model for each provider using the current model tables
• Meet Acme Support, the customer-service agent we'll grow across all eight modules

Why Learn Three SDKs at Once?

The One Universal Idea

Before any code, hold this in your head: every one of these SDKs does the same four things. They only disagree on vocabulary.

That four-step loop is an agent. Anthropic calls the tool request a tool_use block; Gemini calls it a function_call; OpenAI calls it a function_call item too. Same idea, three labels. The animation below runs one request through all three pipelines at once — watch the identical stages light up in each column.

Get Your API Keys

Each provider gives you a secret key. You'll paste each into an environment variable so it never touches your source code. Grab all three now — the free tiers are enough for this whole course.

SET THEMExport all three in your shell (or put them in a .env file). Every SDK below reads its key from these variables automatically — you never pass the key in code.

export ANTHROPIC_API_KEY="sk-ant-..."
export GEMINI_API_KEY="AIza..."
export OPENAI_API_KEY="sk-proj-..."

$env:ANTHROPIC_API_KEY = "sk-ant-..."
$env:GEMINI_API_KEY   = "AIza..."
$env:OPENAI_API_KEY   = "sk-proj-..."

Install the Three SDKs

All three ship official, first-party SDKs for both Python and Node.js. One install line per ecosystem covers the whole course.

pip install anthropic google-genai openai

npm install @anthropic-ai/sdk @google/genai openai

Your First Call — "Hello, Acme"

Time to send the same message to all three. Each snippet creates a client (which auto-reads its API key from the environment), sets a system instruction turning the model into our support agent, sends one user message, and prints the reply. Flip through the six tabs — notice how little actually differs.

# hello_anthropic.py
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment

resp = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=300,
    system="You are Acme Support, a warm, concise e-commerce help agent.",
    messages=[{"role": "user", "content": "Hi! Is my order on its way?"}],
)

# The reply is a list of content blocks; the first text block is the answer.
print(resp.content[0].text)

// hello_anthropic.mjs
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // reads ANTHROPIC_API_KEY

const resp = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 300,
  system: "You are Acme Support, a warm, concise e-commerce help agent.",
  messages: [{ role: "user", content: "Hi! Is my order on its way?" }],
});

const first = resp.content[0];
console.log(first.type === "text" ? first.text : "");

# hello_gemini.py
from google import genai
from google.genai import types

client = genai.Client()  # reads GEMINI_API_KEY from the environment

resp = client.models.generate_content(
    model="gemini-2.5-flash",
    config=types.GenerateContentConfig(
        system_instruction="You are Acme Support, a warm, concise e-commerce help agent.",
    ),
    contents="Hi! Is my order on its way?",
)

print(resp.text)

// hello_gemini.mjs
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({}); // reads GEMINI_API_KEY

const resp = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  config: {
    systemInstruction: "You are Acme Support, a warm, concise e-commerce help agent.",
  },
  contents: "Hi! Is my order on its way?",
});

console.log(resp.text);

# hello_openai.py  (Responses API — OpenAI's recommended default for agents)
from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY from the environment

resp = client.responses.create(
    model="gpt-5.5",
    instructions="You are Acme Support, a warm, concise e-commerce help agent.",
    input="Hi! Is my order on its way?",
)

print(resp.output_text)

// hello_openai.mjs  (Responses API)
import OpenAI from "openai";

const client = new OpenAI(); // reads OPENAI_API_KEY

const resp = await client.responses.create({
  model: "gpt-5.5",
  instructions: "You are Acme Support, a warm, concise e-commerce help agent.",
  input: "Hi! Is my order on its way?",
});

console.log(resp.output_text);

Hi there! I'd be happy to check on your order. Could you share your order
number (it starts with "AC-")? Once I have it I can tell you exactly where
your package is and when it'll arrive.

resp = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "developer", "content": "You are Acme Support, a warm, concise help agent."},
        {"role": "user", "content": "Hi! Is my order on its way?"},
    ],
)
print(resp.choices[0].message.content)

Which Model Should I Use?

Each provider offers a ladder of models trading capability against speed and cost. For this course we default to a balanced mid-tier from each. Here are the current options and our picks.

Meet Acme Support

Rather than a throwaway "weather bot," we'll build one realistic agent and grow it across the whole course: Acme Support, the customer-service assistant for a fictional online store. Every module adds one real capability to it — and builds that capability three ways.

Three Ways, One Idea

Every module ends with this table: the same idea, mapped across the three SDKs' vocabulary. Here's the M00 version — the basics of talking to a model.

Knowledge Check

Module Summary