[
    {
        "role": "user",
        "content": "copilot%20plus%20pcs%20include%20NPU%20for%20light%20duty%20ai%20tasks.%20can%20we%20actuall%20do%20anything%20useful%20with%20it%20from%20command%20line%2C%20such%20as%20with%20python%20and%20a%20library%20or%20api%3F"
    },
    {
        "role": "assistant",
        "content": "Yes \u2014 Copilot+ PCs do give you *useful* access to the NPU (Neural Processing Unit) from the command line and via code (e.g. Python). It\u2019s not just pre-built Windows apps: you can use existing APIs and runtimes to target the NPU, run models locally, profile performance, etc. Below is a breakdown of what\u2019s possible right now, what tools/APIs are available, what limitations exist, and a simple example of how you'd use it in Python.\n\n---\n\n## What is a Copilot+ PC & its NPU capabilities\n\n- A **Copilot+ PC** is a Windows 11 machine with a high-performance NPU capable of **40+ TOPS** (trillion operations per second). Common examples include machines with Qualcomm Snapdragon X Elite/X Plus, Intel Core Ultra 200V series, or AMD Ryzen AI 300 series processors. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))  \n- The NPU is intended for *inference* (i.e. running already-trained models) rather than training. It\u2019s optimized for efficient, low-latency, high-throughput local AI tasks. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))\n\n---\n\n## Existing APIs / Runtimes for NPU access\n\nHere are the key tools Microsoft and others provide (or are working on) for tapping the NPU in your own code:\n\n| API / Runtime | What it Does | Usefulness from Command Line / Code |\n|---|---|---|\n| **Windows ML (WinML)** | It\u2019s the recommended way to run inference using AI-accelerator hardware (NPU, GPU). The system detects which execution providers are available (e.g. QNN for Qualcomm, OpenVINO for Intel), loads the fastest, and falls back if needed. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai)) | You can write a script or app that uses ONNX models and WinML to automatically use the NPU. Works with Python via ONNX runtimes that support Windows ML or through C++/C# etc. |\n| **ONNX Runtime + Olive optimization toolchain** | ONNX models are format-portable; Olive helps with quantization, pruning, etc., to make models more NPU-friendly (e.g. INT8). ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai)) | You can use Python to load ONNX models, quantize/optimize them, and run inference via ONNX Runtime with the appropriate EP (execution provider), which will tap into the NPU. |\n| **Windows App SDK / Windows AI APIs (Microsoft Foundry on Windows)** | A new set of APIs made to expose more Windows ML and NPU-relevant features; includes batched hardware accelerator discovery. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai)) | Apps (including CLI tools, potentially) built with these can more directly target the NPU with less boilerplate. |\n| **DirectML** (for graphics and more general compute) | Expanding support to NPUs, especially in Web / DirectX-style workloads. ([blogs.windows.com](https://blogs.windows.com/windowsdeveloper/2024/08/29/directml-expands-npu-support-to-copilot-pcs-and-webnn/?utm_source=openai)) | Less typical for pure ML model inference \u2014 more useful if you're pushing ML workloads through GPU / graphics pipelines or via WebNN. |\n\n---\n\n## What *you can do now* with Python / CLI\n\nHere are typical workflows and what\u2019s possible right now:\n\n1. **Run an ONNX\tModel Inference via Windows ML / ONNX Runtime**\n\n   Use an ONNX model (pre-trained or your own), convert or quantize it if needed (e.g. to INT8), then use ONNX Runtime which has support for Windows ML / NPU execution providers.\n\n   Example (pseudo-code outline):\n\n   ```python\n   import onnxruntime as ort\n\n   # Assume you have a quantized ONNX model: my_model.onnx\n   sess = ort.InferenceSession(\"my_model.onnx\", providers=[\"WindowsMLExecutionProvider\"])\n   inputs = {sess.get_inputs()[0].name: your_input_data}\n   out = sess.run(None, inputs)\n   print(out)\n   ```\n\n   If Windows MLEP / QNN / OpenVINO EP is available, it should pick the NPU backend automatically. If not, you may need to explicitly specify or ensure your model is compatible.\n\n2. **Model Optimization**\n\n   Using tools like **Olive** (Microsoft\u2019s open-source tool) to quantize, prune, and prepare models. Then run those optimized models on the NPU.\n\n   ```bash\n   # Example (simplified)\n   olive optimize --model my_model.onnx --target hardware=npu --precision=int8\n   # Then use the optimized model in Python with ONNX Runtime\n   ```\n\n3. **Profiling & Monitoring**\n\n   - Use Task Manager to observe live NPU usage. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))  \n   - Use Windows Performance Recorder / Analyzer to log NPU activity and inspect what operations/models are using it. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))  \n\n---\n\n## Limitations & Gotchas\n\n- **Model compatibility & quantization**: Many NPUs support only *lower precision* (e.g. INT8, maybe FP16), so FP32 models may need conversion. If your model uses uncommon operators that aren\u2019t supported by the NPU EP, those parts may run on CPU/GPU instead.\n\n- **Model size & RAM**: NPUs often have limited memory compared to GPU/CPU RAM. If your model is very large, or memory usage high, you\u2019ll need to break it up or use more efficient networks.\n\n- **Tooling maturity**: The Windows ML / ONNX / Foundry + Olive toolchain is still evolving. Some hardware (especially newer Intel/AMD NPUs) may not yet have full support or optimized backends. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))\n\n- **Not yet for training**: These NPUs are designed for inference. Heavy training (e.g. fine-tuning large models) is not their intended use case.\n\n- **Cloud vs Local**: Some Copilot / Copilot+ \u201cassistant\u201d features are still cloud-based. Local models are being introduced (e.g. Phi Silica, a small NPU-optimized local language model), but these are limited in size and feature set. ([windowscentral.com](https://www.windowscentral.com/artificial-intelligence/windows-ai-apis-mccarthy-app-development-npu?utm_source=openai))\n\n---\n\n## What *newer* or upcoming pieces help\n\n- Microsoft is pushing **Windows AI APIs** (via Microsoft Foundry) to let developers ship apps that pick up NPU usage more naturally. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/npu-devices/?utm_source=openai))  \n- ONNX Runtime is getting better execution providers for different NPUs (QNN, OpenVINO). Also tools like **Olive** are ramping up. ([mundobytes.com](https://mundobytes.com/en/How-to-access-the-NPU-in-Copilot-PC/?utm_source=openai))  \n- Enhanced monitoring tools: Task Manager now shows more detailed NPU usage (per-process, engine memory) in newer Windows 11 insider/dev builds. ([windowscentral.com](https://www.windowscentral.com/microsoft/windows-11/windows-11-task-manager-npu-stats-insider?utm_source=openai))  \n\n---\n\n## Example: Using NPU from Python for a small ML task\n\nHere\u2019s a concrete step-by-step you might try (assuming you have a Copilot+ PC with NPU = 40+ TOPS, with Windows 11 latest update):\n\n1. Install ONNX, ONNX Runtime with Windows ML support:\n\n   ```bash\n   pip install onnx onnxruntime\n   ```\n\n2. Obtain or convert a model to an ONNX format. If using e.g. a ResNet or MobileNet or a small LLM, it should have quantized or conversion tools.\n\n3. If needed, use Olive or another quantizer to reduce size / precision to INT8.\n\n4. Write inference code:\n\n   ```python\n   import numpy as np\n   import onnxruntime as ort\n\n   sess = ort.InferenceSession(\"quantized_model.onnx\", providers=[\"WindowsMLExecutionProvider\"])\n   input_name = sess.get_inputs()[0].name\n   dummy_input = np.random.rand(1, 3, 224, 224).astype(np.float32)  # depends on model\n   result = sess.run(None, {input_name: dummy_input})\n   print(result[0].shape)\n   ```\n\n5. Run the script and check Task Manager (Performance tab) to see NPU usage rise; optionally profile with Windows Performance Recorder to see where time is going.  \n\n---\n\nSo in summary: **yes**, you *can* do useful things with the NPU from a command line or with Python \u2014 inferencing ONNX models, running local smart features, prototyping lightweight LLMs. The infrastructure (Windows ML, ONNX, Olive, Foundry APIs) is already there. But for now, it\u2019s mostly in inference / existing-model usage; more advanced cases (large training, mixing custom layers, etc.) are more constrained.  \n\nIf you want, I can pull up a list of Python libraries / models that are already validated to run on these NPUs (by chip vendor) so you can hit the ground running. Want me to gather that?"
    },
    {
        "role": "user",
        "content": "without%20making%20or%20quantizing%20my%20own%20models%2C%20what%20practical%20things%20can%20i%20do%20with%20command%20line%20utilities%20or%20python%20using%20npu%3F"
    },
    {
        "role": "assistant",
        "content": "Here are several practical things you *can do right now*, without needing to build or quantize your own models, that let you tap into the NPU on a Copilot+ PC \u2014 from the command line or via Python. These leverage Microsoft-provided tools, SDKs, and built-in local models already optimized for on-device use.\n\n---\n\n## Key Tools & Models You Can Use\n\n- **Phi Silica** \u2013 a small language model (SLM) Microsoft ships with Copilot+ PCs, optimized for the NPU. It powers local language tasks (text generation, summarization, rewriting, etc.) entirely on-device. ([support.microsoft.com](https://support.microsoft.com/en-us/topic/windows-copilot-ai-components-a9ef14e9-32a7-497f-b780-7b6fb63af793?utm_source=openai))  \n- **Windows Copilot Library / Windows AI components** \u2013 built-in features for image creation, image processing, image transformation, and language intelligence, all local, backed by the NPU. ([support.microsoft.com](https://support.microsoft.com/en-us/topic/windows-copilot-ai-components-a9ef14e9-32a7-497f-b780-7b6fb63af793?utm_source=openai))  \n- **Foundry Local** \u2013 Microsoft's runtime/CLI/SDK that lets you run \"ready-to-use LLMs\" from Microsoft\u2019s catalog locally, automatically selecting hardware execution providers (CPU / GPU / NPU) depending on what's available. You can use it from the command line or through Python/Rust/C++ SDKs. ([github.com](https://github.com/microsoft/Foundry-Local?utm_source=openai))  \n\n---\n\n## What You Can Do *Right Now* from CLI or Python (without training or tweaking models)\n\n| Use Case | How to Do It | What Happens Under the Hood (NPU involvement) |\n|---|---|---|\n| **Chat or Prompting via Foundry Local** | Install Foundry Local via `winget`, then do:<br>`foundry model list`<br>`foundry model run <alias>`<br>Type prompts in interactive mode. ([news.mynavi.jp](https://news.mynavi.jp/techplus/article/20260410-foundrylocalga/?utm_source=openai)) | The system picks a variant optimized for your NPU (if available), downloads it, and runs inference locally. |\n| **Serve LLM as Local API** | Use Foundry Local\u2019s CLI to start the service:<br>`foundry service status`<br>Then send HTTP requests to the local endpoint for completions/summaries. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai)) | The inference occurs locally with acceleration by NPU, if supported. |\n| **Call Phi Silica via Windows AI APIs (Python / SDK)** | Use Windows AI / Copilot Library APIs or the Windows App SDK to invoke tasks like summarization, rewriting etc. (e.g. Microsoft.Windows.AI.Lgenerativemodel) \u2013 though currently sample apps are more in C# / WinUI. ([strathweb.com](https://www.strathweb.com/2025/04/using-phi-silica-in-windows-app-sdk-on-copilot-plus-pc/?utm_source=openai)) | Phi Silica executes locally on the NPU (on Copilot+ PC), no cloud needed. |\n| **Use Foundry Local in Python** | Import the Python SDK provided by Foundry Local to script prompts:<br>```python<br>from foundry_local_sdk import LLMClient <br>client = LLMClient(model=\"qwen2.5-...\")<br>resp = client.chat(\"Hello world\")<br>print(resp)<br>```<br>Based on catalog examples. ([github.com](https://github.com/microsoft/Foundry-Local?utm_source=openai)) | Your code executes locally; hardware acceleration (including NPU) is chosen automatically. |\n| **Image tasks using built-in Windows components** | Tools like Photos app, Snipping Tool, etc., have AI features (background removal, image editing, etc.) that are already optimized. From CLI / PowerShell you might call Windows APIs for image processing. | The Image Processing / Image Transform / Image Creation AI components are optimized for the NPU. ([support.microsoft.com](https://support.microsoft.com/en-us/topic/windows-copilot-ai-components-a9ef14e9-32a7-497f-b780-7b6fb63af793?utm_source=openai)) |\n\n---\n\n## Practical Examples\n\n### 1. Foundry Local in Terminal\n\n```powershell\n# Install Foundry Local\nwinget install Microsoft.FoundryLocal\n\n# List all models available\nfoundry model list\n\n# Run a model interactively\nfoundry model run phi-3.5-mini\n```\n\nYou enter prompt-response mode in the terminal. The variant loaded is picked based on your NPU, if present. ([github.com](https://github.com/microsoft/Foundry-Local?utm_source=openai))\n\n### 2. Use Foundry Local Python SDK\n\n```python\n# Install SDK (if available via pip or via project)\nfrom foundry_local_sdk import LLMClient\n\nclient = LLMClient(model_alias=\"qwen2.5-0.5b\")\nresponse = client.chat(\"Summarize this:\\nWindows Copilot+ PCs include built-in AI components...\")\nprint(\"Response:\", response)\n```\n\nThe library/library runtime should use ONNX Runtime under the hood and route to the NPU if available. ([github.com](https://github.com/microsoft/Foundry-Local?utm_source=openai))\n\n### 3. Build a Chat or Summarize App with Windows AI API\n\nIf you prefer using Microsoft\u2019s Windows App SDK, there's an example/tutorial (WinUI 3) that uses Phi Silica \u2014 but note: it requires a Limited Access Feature (LAF) unlock token. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/apis/phi-silica-winui-tutorial?utm_source=openai))\n\n---\n\n## Things to Check / Prepare\n\n- Ensure you have a **Copilot+ PC** (i.e. Windows 11 version 25H2 or 26H1 or later) with an NPU. If not, some features (like Phi Silica via Windows AI APIs) won\u2019t work. ([support.microsoft.com](https://support.microsoft.com/en-us/topic/windows-copilot-ai-components-a9ef14e9-32a7-497f-b780-7b6fb63af793?utm_source=openai))  \n- Install **Foundry Local** from Microsoft. This gives you the CLI and SDK. ([news.mynavi.jp](https://news.mynavi.jp/techplus/article/20260410-foundrylocalga/?utm_source=openai))  \n- If using Phi Silica via Windows AI APIs / Windows App SDK, you\u2019ll need the **Limited Access Feature token** (to unlock the APIs) in many cases. ([learn.microsoft.com](https://learn.microsoft.com/en-us/windows/ai/apis/phi-silica-winui-tutorial?utm_source=openai))  \n\n---\n\nIf you want, I can send you a ready-to-run Python/CLI script tailored to your Copilot+ PC to test whether your NPU is actually being used (latency, performance, etc.). Do you want that?"
    },
    {
        "role": "user",
        "content": "can%20i%20chat%20with%20foundry%20if%20i%20don%27t%20have%20an%20npu%3F"
    },
    {
        "role": "assistant",
        "content": "Yes \u2014 you *can* use Foundry Local for chatting even if you don\u2019t have an NPU. It will simply use a different hardware backend (CPU or GPU) instead of NPU acceleration. Here are the relevant details and what to expect.\n\n---\n\n## \u2705 How Foundry Local works without an NPU\n\n- The Foundry Local runtime automatically detects what acceleration hardware is available on your machine \u2014 NPU, GPU, or neither. It then picks the best execution provider for your situation. If you *don\u2019t* have an NPU, it falls back to using the CPU (or GPU if present). ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))  \n- Execution providers in Foundry include:\n  - **CPU** (via MLAS \u2013 Microsoft Linear Algebra Subroutines), for hardware without acceleration or to support parts of the model unsupported by accelerators ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai))  \n  - **GPU** and other acceleration options (if your system has them) ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))  \n\n---\n\n## \u26a1 What to expect in terms of performance\n\nIf you're using Foundry Local on your PC without an NPU:\n\n- Latency will usually be higher than on an NPU or modern GPU, especially for larger models. Interactions will be slower.\n- Smaller, lightweight models (e.g. mini, tiny, or distilled variants) will perform much better than larger ones. These may still feel reasonably responsive on a strong CPU.\n- If you do have a compatible GPU, performance will be significantly better when Foundry Local picks the GPU execution provider.\n\n---\n\n## \ud83d\udd27 How to run Foundry Local without an NPU\n\nHere's how you can try it out:\n\n1. **Install Foundry Local**  \n   On Windows (or macOS/Linux), using `winget`, `brew`, or the relevant installer. ([schneider.im](https://www.schneider.im/microsoft-foundry-local-run-ai-models-locally/?utm_source=openai))\n\n2. **List Models**  \n   Use `foundry model list` to see what's available. The catalog includes CPU-compatible models, and variants will be tagged for CPU if no acceleration is available. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai))\n\n3. **Run a Model Using CPU**  \n   If you want to force the CPU version, pick a model alias that ends with `-cpu`, or use the alias but be aware Foundry will pick the best available by default. For example:  \n   ```\n   foundry model run qwen2.5-0.5b\n   ```\n   If you don\u2019t have an NPU or supported GPU, it will use the CPU execution provider. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai))\n\n4. **Interact in CLI**  \n   Once the model is loaded, you can enter prompts in the terminal and get responses. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))\n\n---\n\n## \ud83d\udd0d Example CLI session (no NPU)\n\nHere\u2019s a possible flow:\n\n```bash\n# Install Foundry Local\nwinget install Microsoft.FoundryLocal\n\n# List models\nfoundry model list\n\n# Run a CPU-compatible model\nfoundry model run qwen2.5-0.5b\n\n# Then prompt:\nYou: What is the capital of France?\nModel: Paris.\n\n# Or force CPU model\nfoundry model run qwen2.5-0.5b-instruct-generic-cpu\n```\n\n---\n\n## \ud83e\udde0 Things to keep in mind\n\n- **Choose smaller models**: If you only have a CPU (especially underpowered ones), stick to smaller model variants for better responsiveness.\n- **Memory matters**: CPU-based inference needs sufficient RAM. Foundry Local requires minimum ~8 GB but recommends 16 GB or more. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))  \n- **Offline capability**: Once models are downloaded and cached, you can use them without Internet. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))\n\n---\n\nIf you like, I can test which model variants in Foundry Local run best *without* NPU on typical CPUs, and send you recommendations based on your system specs. Want me to do that?"
    },
    {
        "role": "user",
        "content": "which%20model%20to%20use%20with%2016%20gb%20ram%20thinkpad%20x1%20carbon%20gen%2010%2C%20no%20npu"
    },
    {
        "role": "assistant",
        "content": "Here are my recommendations for which Foundry Local model to pick for a ThinkPad X1 Carbon Gen 10 with **16 GB RAM** and **no NPU**, plus what to expect. I include what works, what to avoid, and some tips to get the best performance.\n\n---\n\n## \ud83d\udca1 System Requirements Reminder\n\nFrom Microsoft\u2019s Foundry Local docs:\n\n- Minimum: **8 GB RAM** + ~3 GB free disk space.  \n- Recommended: **16 GB RAM** + ~15 GB free space. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-local/get-started?utm_source=openai))  \n- If there's no GPU or NPU, Foundry Local will fall back to the **CPU execution provider**. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai))  \n\nSo your 16 GB RAM setup *meets* the recommendation \u2014 but because you lack an accelerator, you're in a more constrained position. The model size you pick will strongly affect responsiveness.\n\n---\n\n## \ud83d\udd0d Which Model Sizes Are Available\n\nFrom the Qwen2.5 model family:\n\n- Sizes available: **0.5B**, **1.5B**, **3B**, **7B**, **14B**, **32B**, and **72B** parameters. ([llmreference.com](https://www.llmreference.com/model-family/qwen-2-5?utm_source=openai))  \n- Smaller ones (0.5B, 1.5B, 3B) are much lighter and intended for lower-resource scenarios. ([qwenlm.github.io](https://qwenlm.github.io/blog/qwen2.5-llm/?trk=public_post_comment-text&utm_source=openai))  \n- Larger ones (14B, 32B) provide better performance but require far more RAM or acceleration. ([canitrun.net](https://canitrun.net/blog/qwen-2.5-complete-model-guide?utm_source=openai))  \n\n---\n\n## \u2705 Best Model Choices for Your Setup (16 GB, CPU only)\n\nHere are the model sizes I think make sense, in descending order of capability vs. resource needs:\n\n| Model Size | Why It\u2019s Suitable | What to Expect |\n|------------|-------------------|----------------|\n| **qwen2.5-3B-instruct-generic-cpu** | Probably the best balance: 3B parameters is a \u201csweet spot\u201d for a reasonably capable CPU, and Foundry Local supports a CPU variant explicitly. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai)) | Slower than smaller models, but should still respond in a few seconds for normal chat prompts. Able to handle medium-length responses. |\n| **qwen2.5-1.5B-instruct-generic-cpu** | If you want snappier responses and less RAM pressure. Very usable for chat tasks, summarization, etc. | Faster responses, lower memory usage; might struggle with very long or complex queries. |\n| **qwen2.5-0.5B-instruct-generic-cpu** | Fastest, lowest RAM usage. If your use is lightweight (notes, short dialogue, simple tasks). | Quickest responses, but less capable for nuance, reasoning, or handling complexity. |\n\n---\n\n## \u26a0\ufe0f Model Sizes Likely Too Heavy\n\n- **qwen2.5-7B-cpu** \u2014 may work on 16 GB, but expect significant swapping, sluggish typing, maybe occasional hangs.  \n- **14B or larger models** \u2014 probably not viable without RAM or swap issues. These typically need GPU/NPU or quantization/offloading. ([canitrun.net](https://canitrun.net/blog/qwen-2.5-complete-model-guide?utm_source=openai))  \n\n---\n\n## \ud83d\udd27 How to Run a Model with Foundry Local on Your Machine\n\nHere\u2019s what you\u2019ll want to do to try one practically:\n\n1. **Install Foundry Local** (via the Windows CLI or official site).  \n2. Open a terminal, list models filtered to CPU variants:\n\n   ```bash\n   foundry model list --filter device=CPU\n   ```\n\n3. Pick one of the recommended CPU variants, e.g.:\n\n   ```bash\n   foundry model run qwen2.5-3B-instruct-generic-cpu\n   ```\n\n   or, if that\u2019s too sluggish:\n\n   ```bash\n   foundry model run qwen2.5-1.5B-instruct-generic-cpu\n   ```\n\n4. Begin chatting! For example:\n\n   ```\n   You: What are useful shortcuts in Windows?\n   Model: ...\n   ```\n\n5. If performance is lagging (e.g. lots of delay or swapping), drop to the 1.5B or 0.5B variant.\n\n---\n\n## \u2699\ufe0f Tips for Better Performance\n\n- Close other major apps when running Foundry Local so more RAM is available.  \n- If you have a GPU, even a modest one, Foundry Local might still pick a GPU\u2010friendly variant automatically. Always check with `foundry model info <model>` to see which \u201cprovider\u201d (CPU, GPU) is being used. ([learn.microsoft.com](https://learn.microsoft.com/en-us/azure/foundry-local/reference/reference-cli?utm_source=openai))  \n- For chat-style workflows, keep prompts relatively short. Long history or long inputs will slow things down.  \n\n---\n\nIf you tell me your CPU model (for example \u201cIntel-Core i7-1365U\u201d, or whatever your ThinkPad X1 has), I can give a recommendation more precisely tuned to your machine. Want me to do that?"
    }
]