Introduce new variables to use desired models and other tweaks

Author: mikesir87

labspace/01-introduction.md

@@ -29,37 +29,15 @@ This Labspace comes with everything you need to get started:
 
 ## Prerequisites
 
-Before starting this workshop, you should have:
+Before starting this workshop, you should have an API key to a model provider. The following providers are supported:
 
-1. **cagent installed** - Follow the installation instructions below
-2. **AI API access** - Choose one of:
-   - OpenAI API key (for GPT-4, GPT-4o)
-   - Anthropic API key (for Claude models)
-   - Google API key (for Gemini models)
+- OpenAI 
+- Anthropic
+- Google (for Gemini models)
 
-## Step 1: Install cagent
+Additionally, this lab will make use of Docker's MCP Gateway, which should already be up and running.
 
-Since you're running this lab on Ubuntu Linux, let's install cagent directly. Run the following commands:
-
-```bash
-# Download the latest cagent Linux binary
-curl -L -o /tmp/cagent https://github.com/docker/cagent/releases/latest/download/cagent-linux-amd64
-
-# Make it executable
-chmod +x /tmp/cagent
-
-# Move it to a location in your PATH
-sudo mv /tmp/cagent /usr/local/bin/cagent
-
-# Verify installation
-cagent version
-```
-
-You should see output showing the cagent version.
-
-## Step 2: Verify Pre-Configured Services
-
-Let's make sure the Labspace services are running:
+Verify it's running by running the following command:
 
 ```bash
 # Check MCP Gateway
@@ -68,6 +46,7 @@ curl http://labspace-mcp-gateway:8080/sse
 
 If the command returns successfully, you're ready to go!
 
+
 ## Workshop Overview
 
 In this workshop we will learn the basics of creating agents and teams of
@@ -82,12 +61,11 @@ agents that do things for you.
 
 | Step | Topic | Description |
 |------|-------|-------------|
-| 2 | Getting Started | Create your first agent and set up API keys |
+| 2 | Getting Started | Create your first agent |
 | 3 | Built-in Tools | File operations, shell commands, memory, and todo tracking |
 | 4 | MCP Integration | Connect to external services (fetch, search, documentation) |
 | 5 | Sharing Agents | Push and pull agents via Docker Hub |
 | 6 | Sub-agents | Build multi-agent teams with specialized roles |
 | 7 | Model Runner | Run local AI models on your local machine (reference only) |
 | 8 | Conclusion | Next steps and advanced topics |
 
-Let's get started!

labspace/02-getting-started.md

@@ -1,85 +1,101 @@
 # Step 2: Getting Started with cagent
 
-## First, let's set up your API keys
+## Install cagent
 
-To use cagent, you'll need at least one API key from your preferred AI provider. Please provide the API key(s) you want to use:
+1. Run the following commands to install cagent into your lab environment:
 
-::variableDefinition[openaikey]{prompt="Enter your OpenAI API key (or leave blank if not using OpenAI)"}
+    ```bash
+    # Download the latest cagent Linux binary
+    curl -L -o /tmp/cagent https://github.com/docker/cagent/releases/latest/download/cagent-linux-amd64
 
-::variableDefinition[anthropickey]{prompt="Enter your Anthropic API key (or leave blank if not using Anthropic)"}
+    # Make it executable
+    chmod +x /tmp/cagent
 
-::variableDefinition[googlekey]{prompt="Enter your Google/Gemini API key (or leave blank if not using Google)"}
+    # Move it to a location in your PATH
+    sudo mv /tmp/cagent /usr/local/bin/cagent
+    ```
 
-## Setting Up Your Environment
+2. Once the install is completed, verify it by checking the version information:
 
-Now that you've provided your API key(s), let's set them in your environment. Copy and run the following commands in the terminal based on the provider(s) you're using:
+    ```bash
+    cagent version
+    ```
 
-```bash
-# For OpenAI models (if you provided an OpenAI key)
-export OPENAI_API_KEY=$$openaikey$$
+    You should see output showing the cagent version.
 
-# For Anthropic models (if you provided an Anthropic key)
-export ANTHROPIC_API_KEY=$$anthropickey$$
 
-# For Gemini models (if you provided a Google key)
-export GOOGLE_API_KEY=$$googlekey$$
-```
+## API setup
+
+In order to complete this lab, you will need an API key from one of the following providers:
+
+::variableSetButton[Use OpenAI]{variables="provider=openai,model=openai/gpt-5-nano,modelShort=gpt-5-nano"}
+
+::variableSetButton[Use Anthropic]{variables="provider=anthropic,model=anthropic/claude-sonnet-4-6,modelShort=claude-sonnet-4-6"}
 
-> **Note:** You only need to set the API keys for the providers you plan to use. At minimum, you need one valid API key to proceed.
+::variableSetButton[Use Gemini]{variables="provider=gemini,model=google/gemini-2.5-flash,modelShort=gemini-2.5-flash"}
 
-## Your First Agent
+ 
 
-Let's create the simplest possible agent. Run this command in the terminal to create `basic_hello.yaml`:
+:::conditionalDisplay{variable="provider" requiredValue="openai"}
+### OpenAI configuration
+
+::variableDefinition[openaikey]{prompt="Enter your OpenAI API key (or leave blank if not using OpenAI)"}
 
 ```bash
-cat > basic_hello.yaml << 'EOF'
-agents:
-  root:
-    model: openai/gpt-4o
-    instruction: You talk like a pirate
-EOF
+export OPENAI_API_KEY=$$openaikey$$
 ```
+:::
 
-Now let's run this amazing agent:
+
+:::conditionalDisplay{variable="provider" requiredValue="anthropic"}
+### Anthropic configuration
+
+::variableDefinition[anthropickey]{prompt="Enter your Anthropic API key (or leave blank if not using Anthropic)"}
 
 ```bash
-cagent run basic_hello.yaml
+# For Anthropic models (if you provided an Anthropic key)
+export ANTHROPIC_API_KEY=$$anthropickey$$
 ```
+:::
 
-If everything is setup correctly, you should see the TUI and be able to ask a
-question to your agent and it should answer in pirate speak.
 
+:::conditionalDisplay{variable="provider" requiredValue="gemini"}
+### Gemini configuration
 
+::variableDefinition[googlekey]{prompt="Enter your Google/Gemini API key (or leave blank if not using Google)"}
 
-To exit the TUI, press `Ctrl+C`.
+```bash
+export GOOGLE_API_KEY=$$googlekey$$
+```
+:::
 
-## Choosing Different Models
 
-If you don't have access to OpenAI, or want to use a different provider, you can easily swap the model in your YAML configuration. Visit [models.dev](https://models.dev) and look for models that exist for your provider.
+## Writing your First Agent
 
-`cagent` supports these providers:
+Let's create the simplest possible agent. 
 
-- **`openai`** - OpenAI models (GPT-4, GPT-4o, etc.)
-- **`anthropic`** - Anthropic models (Claude 3.5 Sonnet, etc.)
-- **`google`** - Google Gemini models
-- **`dmr`** - Use any local [Docker Model Runner](https://docs.docker.com/ai/model-runner/) model that you already have pulled locally
+1. Create a file named `basic_hello.yaml` with the following contents:
 
-For example, to use Anthropic's Claude instead, create a new file:
+    ```yaml save-as=basic_hello.yaml
+    agents:
+      root:
+        model: $$model$$
+        instruction: You talk like a pirate
+    ```
 
-```bash
-cat > basic_hello_claude.yaml << 'EOF'
-agents:
-  root:
-    model: anthropic/claude-3-5-sonnet-20241022
-    instruction: You talk like a pirate
-EOF
-```
+2. Run this amazing agent using the following command:
 
-Then run it:
+    ```bash
+    cagent run basic_hello.yaml
+    ```
 
-```bash
-cagent run basic_hello_claude.yaml
-```
+3. Ask your agent a simple question to see it answer in pirate speak:
+
+    ```console
+    Give me an interesting and lesser-known fact about Docker
+    ```
+
+4. To exit the agent's interface, press `Ctrl+C`.
 
 
 ## Next Steps