सत्र १: Foundry Local को साथ सुरु गर्दै

January 29, 2026 · View on GitHub

अवलोकन

Microsoft Foundry Local ले Azure AI Foundry का क्षमताहरूलाई सिधै तपाईंको Windows 11 विकास वातावरणमा ल्याउँछ, जसले गोपनीयता सुरक्षित गर्दै, न्यून-विलम्बता AI विकासलाई उद्यम-स्तरका उपकरणहरूसँग सक्षम बनाउँछ। यो सत्रले लोकप्रिय मोडेलहरू जस्तै phi, qwen, deepseek, र GPT-OSS-20B को पूर्ण स्थापना, कन्फिगरेसन, र व्यावहारिक परिनियोजन समेट्छ।

सिकाइ उद्देश्यहरू

यो सत्रको अन्त्यसम्म, तपाईं:

  • Windows 11 मा Foundry Local स्थापना र कन्फिगर गर्न सक्नुहुन्छ
  • CLI आदेशहरू र कन्फिगरेसन विकल्पहरूमा निपुण हुनुहुनेछ
  • उत्कृष्ट प्रदर्शनका लागि मोडेल क्यासिङ रणनीतिहरू बुझ्नुहुनेछ
  • phi, qwen, deepseek, र GPT-OSS-20B मोडेलहरू सफलतापूर्वक चलाउन सक्नुहुनेछ
  • Foundry Local प्रयोग गरेर आफ्नो पहिलो AI एप्लिकेसन बनाउन सक्नुहुनेछ

पूर्वआवश्यकताहरू

प्रणाली आवश्यकताहरू

  • Windows 11: संस्करण 22H2 वा पछिल्लो
  • RAM: न्यूनतम 16GB, सिफारिस गरिएको 32GB
  • स्टोरेज: मोडेल र क्यासका लागि 50GB खाली ठाउँ
  • हार्डवेयर: NPU- वा GPU-सक्षम उपकरण प्राथमिक (Copilot+ PC वा NVIDIA GPU)
  • नेटवर्क: मोडेल डाउनलोडका लागि उच्च गतिको इन्टरनेट

विकास वातावरण

# Verify Windows version
winver

# Check available memory
Get-ComputerInfo | Select-Object TotalPhysicalMemory

# Verify PowerShell version (5.1+ required)
$PSVersionTable.PSVersion

# Set up Python environment (recommended)
py -m venv .venv
.venv\Scripts\activate

# Install required dependencies
pip install openai foundry-local-sdk

भाग १: स्थापना र सेटअप

चरण १: Foundry Local स्थापना गर्नुहोस्

Winget प्रयोग गरेर वा GitHub बाट इन्स्टलर डाउनलोड गरेर Foundry Local स्थापना गर्नुहोस्:

# Winget (Windows)
winget install --id Microsoft.FoundryLocal --source winget

# Alternatively: download installer from the official repo
# https://aka.ms/foundry-local-installer

चरण २: स्थापना प्रमाणित गर्नुहोस्

# Check Foundry Local version
foundry --version

# Verify CLI accessibility and categories
foundry --help
foundry model --help
foundry cache --help
foundry service --help

भाग २: CLI बुझ्दै

कोर आदेश संरचना

# General command structure
foundry [category] [command] [options]

# Main categories
foundry model   # manage and run models
foundry service # manage the local service
foundry cache   # manage local model cache

# Common commands
foundry model list              # list available models
foundry model run phi-4-mini  # run a model (downloads as needed)
foundry cache ls                # list cached models

भाग ३: मोडेल क्यासिङ र व्यवस्थापन

Foundry Local ले प्रदर्शन र स्टोरेजलाई अनुकूल बनाउन बुद्धिमान मोडेल क्यासिङ लागू गर्दछ:

# Show cache contents
foundry cache ls

# Optional: change cache directory (advanced)
foundry cache cd "C:\\FoundryLocal\\Cache"
foundry cache ls

भाग ४: व्यावहारिक मोडेल परिनियोजन

Microsoft Phi मोडेलहरू चलाउँदै

# List catalog and run Phi (auto-downloads best variant for your hardware)
foundry model list
foundry model run phi-4-mini

Qwen मोडेलहरूसँग काम गर्दै

# Run Qwen2.5 models (downloads on first run)
foundry model run qwen2.5-7b
foundry model run qwen2.5-14b

DeepSeek मोडेलहरू चलाउँदै

# Run DeepSeek model
foundry model run deepseek-r1-7b

GPT-OSS-20B चलाउँदै

# Run the latest OpenAI open-source model (requires recent Foundry Local and sufficient GPU VRAM)
foundry model run gpt-oss-20b

# Check version if you encounter errors (requires 0.6.87+ per docs)
foundry --version

भाग ५: आफ्नो पहिलो एप्लिकेसन बनाउँदै

आधुनिक च्याट एप्लिकेसन (OpenAI SDK + Foundry Local)

OpenAI SDK र Foundry Local एकीकरण प्रयोग गरेर उत्पादन-तयार च्याट एप्लिकेसन बनाउनुहोस्, हाम्रो नमूना ०१ बाट ढाँचाहरू अनुसरण गर्दै।

# chat_quickstart.py (Sample 01 pattern)
import os
import sys
from openai import OpenAI

try:
    from foundry_local import FoundryLocalManager
    FOUNDRY_SDK_AVAILABLE = True
except ImportError:
    FOUNDRY_SDK_AVAILABLE = False
    print("⚠️ Install foundry-local-sdk: pip install foundry-local-sdk")

def create_client():
    """Create OpenAI client with Foundry Local or Azure OpenAI."""
    # Check for Azure OpenAI configuration
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
    azure_api_key = os.environ.get("AZURE_OPENAI_API_KEY")
    
    if azure_endpoint and azure_api_key:
        # Azure OpenAI path
        model = os.environ.get("MODEL", "your-deployment-name")
        client = OpenAI(
            base_url=f"{azure_endpoint}/openai",
            api_key=azure_api_key,
            default_query={"api-version": "2024-08-01-preview"},
        )
        print(f"🌐 Using Azure OpenAI with model: {model}")
        return client, model
    
    # Foundry Local path with SDK management
    alias = os.environ.get("MODEL", "phi-4-mini")
    if FOUNDRY_SDK_AVAILABLE:
        try:
            # Use FoundryLocalManager for proper service management
            manager = FoundryLocalManager(alias)
            model_info = manager.get_model_info(alias)
            
            client = OpenAI(
                base_url=manager.endpoint,
                api_key=manager.api_key
            )
            model = model_info.id
            print(f"🏠 Using Foundry Local SDK with model: {model}")
            return client, model
        except Exception as e:
            print(f"⚠️ Foundry SDK failed ({e}), using manual configuration")
    
    # Fallback to manual configuration
    base_url = os.environ.get("BASE_URL", "http://localhost:8000")
    api_key = os.environ.get("API_KEY", "")
    model = alias
    
    client = OpenAI(
        base_url=f"{base_url}/v1",
        api_key=api_key
    )
    print(f"🔧 Manual configuration with model: {model}")
    return client, model

def main():
    """Main chat function."""
    client, model = create_client()
    
    print("Foundry Local Chat Interface (type 'quit' to exit)\n")
    conversation_history = []
    
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            break
        
        try:
            # Add user message to history
            conversation_history.append({"role": "user", "content": user_input})
            
            # Create chat completion
            response = client.chat.completions.create(
                model=model,
                messages=conversation_history,
                max_tokens=500,
                temperature=0.7
            )
            
            assistant_message = response.choices[0].message.content
            conversation_history.append({"role": "assistant", "content": assistant_message})
            
            print(f"Assistant: {assistant_message}\n")
            
        except Exception as e:
            print(f"Error: {e}\n")

if __name__ == "__main__":
    main()

च्याट एप्लिकेसन चलाउनुहोस्

# Ensure the model is running in another terminal
foundry model run phi-4-mini

# Option 1: Using FoundryLocalManager (recommended)
python chat_quickstart.py "Explain what Foundry Local is"

# Option 2: Manual configuration with environment variables
set BASE_URL=http://localhost:8000
set MODEL=phi-4-mini
set API_KEY=
python chat_quickstart.py "Write a welcome message"

# Option 3: Azure OpenAI configuration
set AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com
set AZURE_OPENAI_API_KEY=your-api-key
set AZURE_OPENAI_API_VERSION=2024-08-01-preview
set MODEL=your-deployment-name
python chat_quickstart.py "Hello from Azure OpenAI"

भाग ६: समस्या समाधान र उत्कृष्ट अभ्यासहरू

सामान्य समस्याहरू र समाधानहरू

# Issue: "Could not use Foundry SDK" warning
pip install foundry-local-sdk
# Or set environment variables for manual configuration

# Issue: Connection refused
foundry service status
foundry service ps  # Check loaded models

# Issue: Model not found
foundry model list
foundry model run phi-4-mini

# Issue: Cache problems or low disk space
foundry cache ls
foundry cache clean

# Issue: GPT-OSS-20B not supported on your version
foundry --version
winget upgrade --id Microsoft.FoundryLocal

# Test API endpoint
curl http://localhost:8000/v1/models

प्रणाली स्रोतहरू अनुगमन गर्नुहोस् (Windows)

# Quick CPU and process view
Get-Process | Sort-Object -Property CPU -Descending | Select-Object -First 10
Get-Counter '\\Processor(_Total)\\% Processor Time' -SampleInterval 1 -MaxSamples 10

वातावरण भेरिएबलहरू

भेरिएबलविवरणडिफल्टआवश्यक
MODELमोडेल उपनाम वा नामphi-4-miniहोईन
BASE_URLFoundry Local आधार URLhttp://localhost:8000होईन
API_KEYAPI कुञ्जी (सामान्यतया स्थानीयका लागि आवश्यक छैन)""होईन
AZURE_OPENAI_ENDPOINTAzure OpenAI अन्त्य बिन्दु-Azure का लागि
AZURE_OPENAI_API_KEYAzure OpenAI API कुञ्जी-Azure का लागि
AZURE_OPENAI_API_VERSIONAzure API संस्करण2024-08-01-previewहोईन

उत्कृष्ट अभ्यासहरू

  • OpenAI SDK प्रयोग गर्नुहोस्: राम्रो मर्मतयोग्यताका लागि OpenAI SDK लाई कच्चा HTTP अनुरोधहरू भन्दा प्राथमिकता दिनुहोस्
  • FoundryLocalManager: सेवा व्यवस्थापनका लागि आधिकारिक SDK प्रयोग गर्नुहोस् जब उपलब्ध छ
  • त्रुटि ह्यान्डलिङ: उत्पादन एप्लिकेसनहरूको लागि उचित फलब्याक रणनीतिहरू कार्यान्वयन गर्नुहोस्
  • नियमित रूपमा अद्यावधिक गर्नुहोस्: नयाँ मोडेल र फिक्सेसहरू पहुँच गर्न Foundry Local अद्यावधिक राख्नुहोस्
  • सानोबाट सुरु गर्नुहोस्: साना मोडेलहरू (Phi mini, Qwen 7B) बाट सुरु गर्नुहोस् र विस्तार गर्नुहोस्
  • स्रोतहरू अनुगमन गर्नुहोस्: CPU/GPU/मेमोरीलाई ट्र्याक गर्नुहोस् जब प्रम्प्ट र सेटिङहरू ट्युन गर्दै

भाग ७: व्यावहारिक अभ्यासहरू

अभ्यास १: छिटो बहु-मोडेल परीक्षण

# deploy-models.ps1
$models = @(
    "phi-4-mini",
    "qwen2.5-7b"
)
foreach ($model in $models) {
    Write-Host "Running $model..."
    foundry model run $model --verbose
}

अभ्यास २: OpenAI SDK एकीकरण परीक्षण

# sdk_integration_test.py (matching Sample 01 pattern)
import os
from openai import OpenAI
from foundry_local import FoundryLocalManager

def test_model_integration(model_alias):
    """Test OpenAI SDK integration with different models."""
    try:
        # Use FoundryLocalManager for proper setup
        manager = FoundryLocalManager(model_alias)
        model_info = manager.get_model_info(model_alias)
        
        client = OpenAI(
            base_url=manager.endpoint,
            api_key=manager.api_key
        )
        
        # Test basic completion
        response = client.chat.completions.create(
            model=model_info.id,
            messages=[{"role": "user", "content": "Say hello and state your model name."}],
            max_tokens=50
        )
        
        print(f"✅ {model_alias}: {response.choices[0].message.content}")
        return True
    except Exception as e:
        print(f"❌ {model_alias}: {e}")
        return False

# Test multiple models
models_to_test = ["phi-4-mini", "qwen2.5-7b"]
for model in models_to_test:
    test_model_integration(model)

अभ्यास ३: व्यापक सेवा स्वास्थ्य जाँच

# health_check.py
from openai import OpenAI
from foundry_local import FoundryLocalManager

def comprehensive_health_check():
    """Perform comprehensive health check of Foundry Local service."""
    try:
        # Initialize with a common model
        manager = FoundryLocalManager("phi-4-mini")
        client = OpenAI(
            base_url=manager.endpoint,
            api_key=manager.api_key
        )
        
        # 1. Check service connectivity
        models_response = client.models.list()
        available_models = [model.id for model in models_response.data]
        print(f"✅ Service healthy - {len(available_models)} models available")
        
        # 2. Test each available model
        for model_id in available_models:
            try:
                response = client.chat.completions.create(
                    model=model_id,
                    messages=[{"role": "user", "content": "Test"}],
                    max_tokens=10
                )
                print(f"✅ {model_id}: Working")
            except Exception as e:
                print(f"❌ {model_id}: {e}")
        
        return True
    except Exception as e:
        print(f"❌ Service check failed: {e}")
        return False

comprehensive_health_check()

सन्दर्भहरू

अस्वीकरण:
यो दस्तावेज़ AI अनुवाद सेवा Co-op Translator प्रयोग गरेर अनुवाद गरिएको हो। हामी यथासम्भव शुद्धता सुनिश्चित गर्न प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छ। मूल दस्तावेज़ यसको मातृभाषामा आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुनेछैनौं।