Merge pull request #111 from roryp/main

updated foundry local

Author: roryp

.devcontainer/devcontainer.json

@@ -6,15 +6,17 @@
       "installZsh": false,
       "upgradePackages": false
     },
-    "ghcr.io/devcontainers/features/docker-in-docker:2": {},
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {
+      "moby": false
+    },
     "ghcr.io/devcontainers/features/azure-cli:1": {
       "installBicep": true,
       "version": "latest"
     },
     "ghcr.io/azure/azure-dev/azd:0": {
       "version": "stable"
     },
-    "sshd": "latest"
+    "ghcr.io/devcontainers/features/sshd:1": {}
   },
   "customizations": {
     "vscode": {

.gitignore

@@ -46,6 +46,10 @@ buildNumber.properties
 .project
 .classpath
 
+# Node
+node_modules/
+package-lock.json
+
 # OS
 .DS_Store
 .DS_Store?

04-PracticalSamples/README.md

@@ -26,7 +26,7 @@ This chapter showcases **sample projects** that demonstrate generative AI develo
 
 ### Foundry Local Spring Boot Demo
 
-The **[Foundry Local Spring Boot Demo](foundrylocal/README.md)** demonstrates how to integrate with local AI models using the **OpenAI Java SDK**. It showcases connecting to the **Phi-3.5-mini** model running on Foundry Local, allowing you to run AI applications without relying on cloud services.
+The **[Foundry Local Spring Boot Demo](foundrylocal/README.md)** demonstrates how to integrate with local AI models using the **OpenAI Java SDK**. It showcases connecting to models running on Foundry Local (e.g., **Phi-4-mini**), with automatic model detection, allowing you to run AI applications without relying on cloud services.
 
 ### Pet Story Generator
 

04-PracticalSamples/foundrylocal/README.md

@@ -27,12 +27,20 @@ Before starting this tutorial, make sure you have:
 
 ### **Install Foundry Local:**
 
+> **Note:** Foundry Local CLI is available on **Windows** and **macOS** only. Linux is supported via the [Foundry Local SDKs](https://github.com/microsoft/Foundry-Local) (Python, JavaScript, C#, Rust).
+
 ```bash
 # Windows
 winget install Microsoft.FoundryLocal
 
-# macOS (after installing)
-foundry model run phi-3.5-mini
+# macOS
+brew tap microsoft/foundrylocal
+brew install foundrylocal
+```
+
+Verify the installation:
+```bash
+foundry --version
 ```
 
 ## Project Overview
@@ -52,12 +60,13 @@ This project consists of four main components:
 
 ```properties
 foundry.local.base-url=http://localhost:5273/v1
-foundry.local.model=Phi-3.5-mini-instruct-cuda-gpu:1
+# foundry.local.model is auto-detected from Foundry Local. Set it here to override:
+# foundry.local.model=Phi-4-mini-instruct-cuda-gpu:5
 ```
 
 **What this does:**
-- **base-url**: Specifies where Foundry Local is running, including the `/v1` path for OpenAI API compatibility. **Note**: Foundry Local dynamically assigns a port, so check your actual port using `foundry service status`
-- **model**: Names the AI model to use for text generation, including the version number (e.g., `:1`). Use `foundry model list` to see available models with their exact IDs
+- **base-url**: Specifies where Foundry Local is running, including the `/v1` path for OpenAI API compatibility. The default port is `5273`. If the port differs, check it with `foundry service status`.
+- **model** (optional): Names the AI model to use for text generation. **By default, the application auto-detects the model** by querying the Foundry Local `/v1/models` endpoint at startup, so you don't need to set this. You can still set it explicitly to override auto-detection if needed.
 
 **Key concept:** Spring Boot automatically loads these properties and makes them available to your application using the `@Value` annotation.
 
@@ -117,19 +126,24 @@ public class FoundryLocalService {
     @Value("${foundry.local.base-url:http://localhost:5273/v1}")
     private String baseUrl;
 
-    @Value("${foundry.local.model:Phi-3.5-mini-instruct-cuda-gpu:1}")
-    private String model;
+    @Value("${foundry.local.model:}")
+    private String model;    // Auto-detected if empty
 ```
 
 **What this does:**
 - `@Service` tells Spring this class provides business logic
 - `@Value` injects configuration values from application.properties
-- The `:default-value` syntax provides fallback values if properties aren't set
+- The model defaults to empty, which triggers **auto-detection** from Foundry Local at startup. This means the app works with any model loaded in Foundry Local without manual configuration.
 
 #### Client Initialization:
 ```java
 @PostConstruct
 public void init() {
+    // Auto-detect the model from Foundry Local if not explicitly configured
+    if (model == null || model.isBlank()) {
+        model = detectModel();
+    }
+
     this.openAIClient = OpenAIOkHttpClient.builder()
             .baseUrl(baseUrl)                // Base URL already includes /v1 from configuration
             .apiKey("not-needed")            // Local server doesn't need real API key
@@ -139,6 +153,7 @@ public void init() {
 
 **What this does:**
 - `@PostConstruct` runs this method after Spring creates the service
+- If no model is configured, it queries Foundry Local's `/v1/models` endpoint and picks the first loaded model
 - Creates an OpenAI client that points to your local Foundry Local instance
 - The base URL from `application.properties` already includes `/v1` for OpenAI API compatibility
 - API key is set to "not-needed" because local development doesn't require authentication
@@ -216,52 +231,70 @@ Here's the complete flow when you run the application:
 
 1. **Startup**: Spring Boot starts and reads `application.properties`
 2. **Service Creation**: Spring creates `FoundryLocalService` and injects configuration values
-3. **Client Setup**: `@PostConstruct` initializes the OpenAI client to connect to Foundry Local
-4. **Demo Execution**: `CommandLineRunner` executes after startup
-5. **AI Call**: The demo calls `foundryLocalService.chat()` with a test message
-6. **API Request**: Service builds and sends OpenAI-compatible request to Foundry Local
-7. **Response Processing**: Service extracts and returns the AI's response
-8. **Display**: Application prints the response and exits
+3. **Model Detection**: If no model is configured, the service queries Foundry Local's `/v1/models` endpoint and uses the first available model automatically
+4. **Client Setup**: `@PostConstruct` initializes the OpenAI client to connect to Foundry Local
+5. **Demo Execution**: `CommandLineRunner` executes after startup
+6. **AI Call**: The demo calls `foundryLocalService.chat()` with a test message
+7. **API Request**: Service builds and sends OpenAI-compatible request to Foundry Local
+8. **Response Processing**: Service extracts and returns the AI's response
+9. **Display**: Application prints the response and exits
 
 ## Setting Up Foundry Local
 
-To set up Foundry Local, follow these steps:
-
 1. **Install Foundry Local** using the instructions in the [Prerequisites](#prerequisites) section.
 
-2. **Check the dynamically assigned port**. Foundry Local automatically assigns a port when it starts. Find your port with:
+2. **Start the service** (if not already running):
+   ```bash
+   foundry service start
+   ```
+
+3. **Check the service status** to confirm it is running and note the port:
    ```bash
    foundry service status
    ```
-   
-   **Optional**: If you prefer to use a specific port (e.g., 5273), you can configure it manually:
+
+4. **Download and run a model** (downloads on first run, cached for subsequent runs):
    ```bash
-   foundry service set --port 5273
+   foundry model run phi-4-mini
    ```
+   This opens an interactive chat session. You can exit with `Ctrl+C`. The model stays loaded in the service.
+
+   > **Tip:** Run `foundry model list` to see all available models. Replace `phi-4-mini` with any alias from the catalog (e.g., `qwen2.5-0.5b` for a smaller/faster model).
 
-3. **Download the AI model** you want to use, for example, `phi-3.5-mini`, with the following command:
+5. **Verify the model is loaded:**
    ```bash
-   foundry model run phi-3.5-mini
+   foundry service ps
    ```
 
-4. **Configure the application.properties** file to match your Foundry Local settings:
-   - Update the port in `base-url` (from step 2), ensuring it includes `/v1` at the end
-   - Update the model name to include the version number (check with `foundry model list`)
-   
-   Example:
+6. **Update `application.properties`** if needed:
+   - The default `base-url` (`http://localhost:5273/v1`) matches the default CLI port. Update only if `foundry service status` shows a different port.
+   - The model is **auto-detected** at startup — no configuration needed.
+
    ```properties
    foundry.local.base-url=http://localhost:5273/v1
-   foundry.local.model=Phi-3.5-mini-instruct-cuda-gpu:1
+   # Model is auto-detected. Uncomment below to override:
+   # foundry.local.model=Phi-4-mini-instruct-cuda-gpu:5
    ```
 
 ## Running the Application
 
-### Step 1: Start Foundry Local
+### Step 1: Ensure a model is loaded in Foundry Local
+```bash
+foundry service ps
+```
+If no models are listed, load one:
 ```bash
-foundry model run phi-3.5-mini
+foundry model run phi-4-mini
 ```
 
 ### Step 2: Build and Run the Application
+In a separate terminal:
+```bash
+cd 04-PracticalSamples/foundrylocal
+mvn spring-boot:run
+```
+
+Or build and run as a JAR:
 ```bash
 mvn clean package
 java -jar target/foundry-local-spring-boot-0.0.1-SNAPSHOT.jar
@@ -274,11 +307,9 @@ java -jar target/foundry-local-spring-boot-0.0.1-SNAPSHOT.jar
 Calling Foundry Local service...
 Sending message: Hello! Can you tell me what you are and what model you're running?
 Response from Foundry Local:
-Hello! I'm Phi-3.5, a small language model created by Microsoft. I'm currently running 
-as the Phi-3.5-mini-instruct model, which is designed to be helpful, harmless, and honest 
-in my interactions. I can assist with a wide variety of tasks including answering 
-questions, helping with analysis, creative writing, coding, and general conversation. 
-Is there something specific you'd like help with today?
+Hello! I'm Phi, an AI developed by Microsoft. I can assist with a wide variety of 
+tasks including answering questions, helping with analysis, creative writing, coding, 
+and general conversation. How can I help you today?
 =========================
 ```
 
@@ -291,29 +322,26 @@ For more examples, see [Chapter 04: Practical samples](../README.md)
 ### Common Issues
 
 **"Connection refused" or "Service unavailable"**
-- Make sure Foundry Local is running: `foundry model list`
-- Check the actual port Foundry Local is using: `foundry service status`
-- Update your `application.properties` with the correct port, ensuring the URL ends with `/v1`
-- Alternatively, set a specific port if desired: `foundry service set --port 5273`
-- Try restarting Foundry Local: `foundry model run phi-3.5-mini`
-
-**"Model not found" or "404 Not Found" errors**
-- Check available models with their exact IDs: `foundry model list`
-- Update the model name in `application.properties` to match exactly, including the version number (e.g., `Phi-3.5-mini-instruct-cuda-gpu:1`)
-- Ensure the `base-url` includes `/v1` at the end: `http://localhost:5273/v1`
-- Download the model if needed: `foundry model run phi-3.5-mini`
+- Check the service: `foundry service status`
+- Restart if needed: `foundry service restart`
+- Verify the port in `application.properties` matches `foundry service status` output
+- Ensure the URL ends with `/v1`: `http://localhost:5273/v1`
+
+**"No model found" at startup**
+- The application auto-detects the model. Ensure at least one model is loaded: `foundry service ps`
+- If no models are loaded: `foundry model run phi-4-mini`
+- If you overrode the model name in `application.properties`, verify it matches `foundry model list`
 
 **"400 Bad Request" errors**
 - Verify the base URL includes `/v1`: `http://localhost:5273/v1`
-- Check that the model ID matches exactly what's shown in `foundry model list`
 - Ensure you're using `maxCompletionTokens()` in your code (not the deprecated `maxTokens()`)
 
 **Maven compilation errors**
 - Ensure Java 21 or higher: `java -version`
 - Clean and rebuild: `mvn clean compile`
 - Check internet connection for dependency downloads
 
-**Application starts but no output**
-- Verify Foundry Local is responding: Check `http://localhost:5273/v1/models` or run `foundry service status`
-- Check application logs for specific error messages
-- Ensure the model is fully loaded and ready
+**Service connection problems**
+- If you see `Request to local service failed`, run: `foundry service restart`
+- Check loaded models: `foundry service ps`
+- View service logs: `foundry service diag`

04-PracticalSamples/foundrylocal/src/main/java/com/example/FoundryLocalService.java

@@ -1,12 +1,18 @@
 package com.example;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.openai.client.OpenAIClient;
 import com.openai.client.okhttp.OpenAIOkHttpClient;
 import com.openai.models.chat.completions.*;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import jakarta.annotation.PostConstruct;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
 
 /**
  * Service for connecting to locally running AI models via Foundry Local.
@@ -31,8 +37,8 @@ public class FoundryLocalService {
     @Value("${foundry.local.base-url:http://localhost:5273/v1}")
     private String baseUrl;  // Where your local AI server is running
 
-    @Value("${foundry.local.model:Phi-3.5-mini-instruct-cuda-gpu:1}")
-    private String model;    // Which local AI model to use
+    @Value("${foundry.local.model:}")
+    private String model;    // Which local AI model to use (auto-detected if empty)
 
     // OpenAI client configured to talk to local server instead of OpenAI's servers
     private OpenAIClient openAIClient;
@@ -46,19 +52,51 @@ public class FoundryLocalService {
      */
     @PostConstruct
     public void init() {
-        // Create OpenAI client but point it to local server instead of OpenAI
-        // This works because local AI servers often implement OpenAI-compatible APIs
+        // Auto-detect the model from Foundry Local if not explicitly configured
+        if (model == null || model.isBlank()) {
+            model = detectModel();
+        }
+
         System.out.println("Initializing Foundry Local client:");
         System.out.println("  Base URL: " + baseUrl);
         System.out.println("  Model: " + model);
 
+        // Create OpenAI client but point it to local server instead of OpenAI
+        // This works because local AI servers often implement OpenAI-compatible APIs
         this.openAIClient = OpenAIOkHttpClient.builder()
                 .baseUrl(baseUrl)                   // Local server endpoint with /v1 path for OpenAI API compatibility
                 .apiKey("not-needed")               // Local servers usually don't need real API keys
                 .build();
 
         System.out.println("Client initialized successfully");
     }
+
+    /**
+     * Query the Foundry Local /v1/models endpoint and return the first available model ID.
+     * This makes the app work regardless of which model variant is loaded.
+     */
+    private String detectModel() {
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(baseUrl + "/models"))
+                    .GET()
+                    .build();
+            HttpResponse<String> response = HttpClient.newHttpClient()
+                    .send(request, HttpResponse.BodyHandlers.ofString());
+            JsonNode root = new ObjectMapper().readTree(response.body());
+            JsonNode data = root.get("data");
+            if (data != null && data.isArray() && !data.isEmpty()) {
+                String detected = data.get(0).get("id").asText();
+                System.out.println("Auto-detected model from Foundry Local: " + detected);
+                return detected;
+            }
+        } catch (Exception e) {
+            System.err.println("Could not auto-detect model from " + baseUrl + "/models: " + e.getMessage());
+        }
+        throw new RuntimeException(
+            "No model found. Make sure Foundry Local is running at " + baseUrl +
+            " with a model loaded, or set foundry.local.model in application.properties.");
+    }
 
     /**
      * Send a message to the local AI model and get a response.

04-PracticalSamples/foundrylocal/src/main/resources/application.properties

@@ -1,2 +1,2 @@
 foundry.local.base-url=http://localhost:5273/v1
-foundry.local.model=Phi-3.5-mini-instruct-cuda-gpu:1
+# foundry.local.model is auto-detected from Foundry Local. Set it here to override: