Learn AI fundamentals without frameworks. Just Python, APIs, and clarity.
When I started learning AI development, I found endless tutorials on various frameworks and libraries. But when something broke, I had no idea what was actually happening under the hood. I couldn't debug issues, optimize performance, or make informed architectural decisions.
This course fills that gap. It teaches you what AI systems actually do, stripped of abstractions and marketing jargon. You'll learn the foundational patterns that all AI applications use - whether they admit it or not.
Frameworks have their place. I use them. I like several of them. But jumping into a framework without understanding the fundamentals is inefficient. You build on shaky ground.
This course teaches you what's really happening when you:
- Chat with an AI
- Give it memory
- Make it use tools
- Have it search your documents
- Build multi-step workflows
Once you understand these patterns, you can use any framework effectively—or build exactly what you need without one.
The industry loves complex terminology. Here's what things really are:
| Industry Term | What It Actually Is |
|---|---|
| AI Agents | Python functions the AI decides to call |
| Memory/Context | A Python list of messages you send with each request |
| RAG (Retrieval Augmented Generation) | Search for relevant text + add to prompt + ask AI |
| Multi-Agent Systems | Sequential API calls with logic between them |
| Embeddings/Vector DBs | Useful for large datasets, but keyword search works fine for most cases |
| Prompt Chaining | Call AI → process result → call AI again |
That's it. No magic. Just API calls and basic programming.
This course now follows a clean 10-step canonical path:
- First AI Call - The basic pattern every AI application uses
- Memory as List - The stateless truth behind chatbots
- Memory with
previous_response_id- OpenAI convenience chaining - Structured Outputs - Turning model output into typed, validated data
- Tool Calling - Making AI take actions through functions
- RAG - Making AI answer questions from your documents
- Conversational RAG - Adding follow-up questions to document Q&A
- Streaming - Displaying AI responses word-by-word in real-time
- Prompt Chaining - Building multi-step AI workflows
- Capstone (OpenAI-only) - One end-to-end project combining everything
By the end, you'll understand how production AI systems work under the hood.
- OpenAI examples use the Responses API (
client.responses.create(...)), which is the recommended primary API for new projects. - Anthropic examples use the current
messagesAPI patterns. - Models are configurable via env vars:
OPENAI_MODEL(default in examples:gpt-4.1)ANTHROPIC_MODEL(default in examples:claude-sonnet-4-6)
You only need to know Python. That's it.
No machine learning background. No advanced math. No framework experience.
If you can write functions, loops, and understand lists and dictionaries, you're ready.
1. Clone this repository
git clone https://github.com/jmedia65/learn-ai-right.git
cd learn-ai-right2. Install dependencies
pip install -r requirements.txt3. Set up your API keys
Copy .env.example to .env:
cp .env.example .envAdd your API keys to .env:
ANTHROPIC_API_KEY=your_anthropic_key_here
OPENAI_API_KEY=your_openai_key_here
# Optional:
# ANTHROPIC_MODEL=claude-sonnet-4-6
# OPENAI_MODEL=gpt-4.1
Get API keys:
- Anthropic: https://console.anthropic.com/
- OpenAI: https://platform.openai.com/api-keys
4. Start with the first module
cd 01-first-ai-call
python 01_anthropic_basic.pyEach module contains:
- A README explaining the concept
- OpenAI examples (all steps)
- Anthropic companion examples (most steps)
- Heavily commented code showing exactly what's happening
- A
Quick ExerciseandWhat Breaks in Productionsection for deliberate practice
Work through them in order:
Learn the foundational pattern: initialize → call → extract response.
Understand how chatbots remember context (spoiler: it's just a list).
Learn OpenAI's state-chaining convenience API after mastering list-based memory.
Bridge module: get typed, validated outputs before tool calling.
Make AI take actions by calling your Python functions.
Make AI answer questions from your own documents.
Add follow-up questions to your document Q&A system.
Display AI responses in real-time, word by word.
Build multi-step AI workflows and "agent" systems.
Build one complete AI Learning Coach that combines memory, structured outputs, tools, RAG, streaming, and chaining.
I'm Max Braglia, and I write about AI engineering at maxbraglia.substack.com. I built this course because I wish it existed when I started learning AI development.
If you find this valuable, consider subscribing to my newsletter where I share practical AI development insights.
MIT License - use this code however you want. Learn, build, teach others.