# ഫൗണ്ട്രി ലോക്കൽ എഎപി സാമ്പിൾ

OpenAI SDK-യിൽ ആശ്രയിക്കാതെ Microsoft Foundry Local-നെ REST API സേവനമായി എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ സാമ്പിൾ കാണിക്കുന്നു. പരമാവധി നിയന്ത്രണത്തിനും ഇഷ്ടാനുസൃതീകരണത്തിനും നേരിട്ട് HTTP ഇന്റഗ്രേഷൻ മാതൃകകൾ ഇത് പ്രദർശിപ്പിക്കുന്നു.

## അവലോകനം

Microsoft-ന്റെ ഔദ്യോഗിക Foundry Local മാതൃകകളുടെ അടിസ്ഥാനത്തിൽ, ഈ സാമ്പിൾ നൽകുന്നത്:
- FoundryLocalManager-ഉടൻ നേരിട്ട് REST API ഇന്റഗ്രേഷൻ
- ഇഷ്ടാനുസൃത HTTP ക്ലയന്റ് നടപ്പാക്കൽ
- മോഡൽ മാനേജ്മെന്റ്, ആരോഗ്യ നിരീക്ഷണം
- സ്ട്രീമിംഗ്, നോൺ-സ്ട്രീമിംഗ് പ്രതികരണ കൈകാര്യം
- പ്രൊഡക്ഷൻ-സജ്ജമായ പിശക് കൈകാര്യം ചെയ്യലും റിട്രൈ ലജിക്കും

## മുൻകൂട്ടി ആവശ്യങ്ങൾ

1. **Foundry Local ഇൻസ്റ്റലേഷൻ**
   ```powershell
   # GitHub റിലീസുകളിൽ നിന്ന് ഇൻസ്റ്റാൾ ചെയ്യുക
   winget install Microsoft.FoundryLocal
   ```

2. **Python ആശ്രിതങ്ങൾ**
   ```bash
   pip install foundry-local-sdk requests asyncio aiohttp
   ```

## ആർക്കിടെക്ചർ

```
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Your App      │───▶│  REST API Client │───▶│  Foundry Local  │
│                 │    │                  │    │   Service       │
│ - Custom Logic  │    │ - HTTP Requests  │    │ - Model Loading │
│ - Business Rules│    │ - Authentication │    │ - Inference     │
│ - Data Pipeline │    │ - Error Handling │    │ - Health Check  │
└─────────────────┘    └──────────────────┘    └─────────────────┘
```

## പ്രധാന സവിശേഷതകൾ

### 1. **നേരിട്ട് HTTP ഇന്റഗ്രേഷൻ**
- SDK ആശ്രിതത്വമില്ലാത്ത ശുദ്ധ REST API കോൾസ്
- ഇഷ്ടാനുസൃത ഓതന്റിക്കേഷൻ, ഹെഡറുകൾ
- അഭ്യർത്ഥന/പ്രതികരണ കൈകാര്യം ചെയ്യലിൽ പൂർണ്ണ നിയന്ത്രണം

### 2. **മോഡൽ മാനേജ്മെന്റ്**
- ഡൈനാമിക് മോഡൽ ലോഡിംഗ്, അൺലോഡിംഗ്
- ആരോഗ്യ നിരീക്ഷണം, നില പരിശോധിക്കൽ
- പ്രകടന മെട്രിക്‌സ് ശേഖരണം

### 3. **പ്രൊഡക്ഷൻ മാതൃകകൾ**
- എക്സ്പൊണൻഷ്യൽ ബാക്ക്ഓഫ് ഉപയോഗിച്ചുള്ള റിട്രൈ മെക്കാനിസങ്ങൾ
- ഫാൾട്ട് ടോളറൻസിനുള്ള സർക്യൂട്ട് ബ്രേക്കർ
- സമഗ്രമായ ലോഗിംഗ്, നിരീക്ഷണം

### 4. **ഫ്ലെക്സിബിൾ പ്രതികരണ കൈകാര്യം**
- റിയൽ-ടൈം ആപ്ലിക്കേഷനുകൾക്കായി സ്ട്രീമിംഗ് പ്രതികരണങ്ങൾ
- ഉയർന്ന ത്രൂപുട്ട് സാഹചര്യങ്ങൾക്ക് ബാച്ച് പ്രോസസ്സിംഗ്
- ഇഷ്ടാനുസൃത പ്രതികരണ പാഴ്സിംഗ്, സാധുത പരിശോധന

## ഉപയോഗ ഉദാഹരണങ്ങൾ

### അടിസ്ഥാന API ഇന്റഗ്രേഷൻ
```python
from api_client import FoundryAPIClient

# API ക്ലയന്റ് ആരംഭിക്കുക
client = FoundryAPIClient()

# ലളിതമായ പൂർത്തീകരണം
response = await client.complete(
    prompt="Explain quantum computing",
    model="phi-4-mini",
    max_tokens=500
)
print(response.content)
```

### സ്ട്രീമിംഗ് ഇന്റഗ്രേഷൻ
```python
# റിയൽ-ടൈം ആപ്ലിക്കേഷനുകൾക്കായി സ്ട്രീം പ്രതികരണങ്ങൾ
async for chunk in client.stream_complete(
    prompt="Write a story about AI",
    model="phi-4-mini"
):
    print(chunk.content, end="", flush=True)
```

### ആരോഗ്യ നിരീക്ഷണം
```python
# സേവനാരോഗ്യം പരിശോധിക്കുക
health = await client.health_check()
print(f"Service Status: {health.status}")
print(f"Active Models: {health.loaded_models}")
print(f"Memory Usage: {health.memory_usage}")
```

## ഫയൽ ഘടന

```
07/
├── README.md              # This documentation
├── requirements.txt       # Python dependencies
├── api_client.py         # Core API client implementation
├── health_monitor.py     # Health checking and monitoring
├── examples/
│   ├── basic_usage.py    # Simple API integration example
│   ├── streaming.py      # Streaming response example
│   ├── batch_processing.py # Batch processing example
│   └── production.py     # Production-ready implementation
└── tests/
    ├── test_api_client.py    # Unit tests for API client
    └── test_integration.py   # Integration tests
```

## Microsoft Foundry Local ഇന്റഗ്രേഷൻ

ഈ സാമ്പിൾ Microsoft-ന്റെ ഔദ്യോഗിക മാതൃകകൾ പിന്തുടരുന്നു:

1. **SDK ഇന്റഗ്രേഷൻ**: സേവന മാനേജ്മെന്റിനായി `FoundryLocalManager` ഉപയോഗിക്കുന്നു
2. **REST എന്റ്പോയിന്റുകൾ**: `/v1/chat/completions` ഉൾപ്പെടെ നേരിട്ട് കോൾസ്
3. **ഓതന്റിക്കേഷൻ**: ലോക്കൽ സേവനങ്ങൾക്ക് ശരിയായ API കീ കൈകാര്യം
4. **മോഡൽ മാനേജ്മെന്റ്**: കാറ്റലോഗ് ലിസ്റ്റിംഗ്, ഡൗൺലോഡിംഗ്, ലോഡിംഗ് മാതൃകകൾ
5. **പിശക് കൈകാര്യം**: Microsoft ശുപാർശ ചെയ്ത പിശക് കോഡുകളും പ്രതികരണങ്ങളും

## ആരംഭിക്കൽ

1. **ആശ്രിതങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക**
   ```bash
   pip install -r requirements.txt
   ```

2. **അടിസ്ഥാന ഉദാഹരണം പ്രവർത്തിപ്പിക്കുക**
   ```bash
   python examples/basic_usage.py
   ```

3. **സ്ട്രീമിംഗ് പരീക്ഷിക്കുക**
   ```bash
   python examples/streaming.py
   ```

4. **പ്രൊഡക്ഷൻ സജ്ജീകരണം**
   ```bash
   python examples/production.py
   ```

## കോൺഫിഗറേഷൻ

ഇഷ്ടാനുസൃതീകരണത്തിനുള്ള പരിസ്ഥിതി വ്യത്യാസങ്ങൾ:
- `FOUNDRY_MODEL`: ഉപയോഗിക്കാനുള്ള ഡിഫോൾട്ട് മോഡൽ (ഡിഫോൾട്ട്: "phi-4-mini")
- `FOUNDRY_TIMEOUT`: അഭ്യർത്ഥന ടൈംഔട്ട് സെക്കൻഡുകളിൽ (ഡിഫോൾട്ട്: 30)
- `FOUNDRY_RETRIES`: റിട്രൈ ശ്രമങ്ങളുടെ എണ്ണം (ഡിഫോൾട്ട്: 3)
- `FOUNDRY_LOG_LEVEL`: ലോഗിംഗ് ലെവൽ (ഡിഫോൾട്ട്: "INFO")

## മികച്ച പ്രാക്ടീസുകൾ

1. **കണക്ഷൻ മാനേജ്മെന്റ്**: മികച്ച പ്രകടനത്തിനായി HTTP കണക്ഷനുകൾ പുനരുപയോഗിക്കുക
2. **പിശക് കൈകാര്യം**: എക്സ്പൊണൻഷ്യൽ ബാക്ക്ഓഫ് ഉപയോഗിച്ച് ശരിയായ റിട്രൈ ലജിക്ക് നടപ്പാക്കുക
3. **സ്രോതസ്സ് നിരീക്ഷണം**: മോഡൽ മെമ്മറി ഉപയോഗവും പ്രകടനവും ട്രാക്ക് ചെയ്യുക
4. **സുരക്ഷ**: ലോക്കൽ സേവനങ്ങൾക്കായി പോലും ശരിയായ ഓതന്റിക്കേഷൻ ഉപയോഗിക്കുക
5. **ടെസ്റ്റിംഗ്**: യൂണിറ്റ്, ഇന്റഗ്രേഷൻ ടെസ്റ്റുകൾ ഉൾപ്പെടുത്തുക

## പ്രശ്നപരിഹാരം

### സാധാരണ പ്രശ്നങ്ങൾ

**സേവനം പ്രവർത്തിക്കുന്നില്ല**
```bash
# ഫൗണ്ട്രി ലോക്കൽ നില പരിശോധിക്കുക
foundry status

# ആവശ്യമെങ്കിൽ ആരംഭിക്കുക
foundry start
```

**മോഡൽ ലോഡിംഗ് പ്രശ്നങ്ങൾ**
```bash
# ലഭ്യമായ മോഡലുകൾ പട്ടികപ്പെടുത്തുക
foundry model list

# പ്രത്യേക മോഡൽ ഡൗൺലോഡ് ചെയ്യുക
foundry model download phi-4-mini
```

**കണക്ഷൻ പിശകുകൾ**
- Foundry Local ശരിയായ പോർട്ടിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക
- ഫയർവാൾ ക്രമീകരണങ്ങൾ പരിശോധിക്കുക
- ശരിയായ ഓതന്റിക്കേഷൻ ഹെഡറുകൾ ഉറപ്പാക്കുക

## പ്രകടന മെച്ചപ്പെടുത്തൽ

1. **കണക്ഷൻ പൂലിംഗ്**: ഒന്നിലധികം അഭ്യർത്ഥനകൾക്കായി സെഷൻ ഒബ്ജക്റ്റുകൾ ഉപയോഗിക്കുക
2. **അസിങ്ക്രൺ ഓപ്പറേഷനുകൾ**: സമകാലിക അഭ്യർത്ഥനകൾക്കായി asyncio പ്രയോജനം ചെയ്യുക
3. **കാഷിംഗ്**: അനുയോജ്യമായിടത്ത് മോഡൽ പ്രതികരണങ്ങൾ കാഷ് ചെയ്യുക
4. **നിരീക്ഷണം**: പ്രതികരണ സമയങ്ങൾ ട്രാക്ക് ചെയ്ത് ടൈംഔട്ടുകൾ ക്രമീകരിക്കുക

## പഠന ഫലങ്ങൾ

ഈ സാമ്പിൾ പൂർത്തിയാക്കിയ ശേഷം നിങ്ങൾക്ക് മനസ്സിലാകും:
- Foundry Local-ഉടൻ നേരിട്ട് REST API ഇന്റഗ്രേഷൻ
- ഇഷ്ടാനുസൃത HTTP ക്ലയന്റ് നടപ്പാക്കൽ മാതൃകകൾ
- പ്രൊഡക്ഷൻ-സജ്ജമായ പിശക് കൈകാര്യം ചെയ്യലും നിരീക്ഷണവും
- Microsoft Foundry Local സേവന ആർക്കിടെക്ചർ
- ലോക്കൽ AI സേവനങ്ങൾക്ക് പ്രകടന മെച്ചപ്പെടുത്തൽ സാങ്കേതിക വിദ്യകൾ

## അടുത്ത ഘട്ടങ്ങൾ

- സാമ്പിൾ 08: Windows 11 ചാറ്റ് ആപ്ലിക്കേഷൻ പരിശോധിക്കുക
- സാമ്പിൾ 09: മൾട്ടി-ഏജന്റ് ഓർക്കസ്ട്രേഷൻ പരീക്ഷിക്കുക
- സാമ്പിൾ 10: Foundry Local ടൂൾസ് ഇന്റഗ്രേഷൻ പഠിക്കുക

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:  
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->