...

app/auth.py

@@ -1,19 +1,34 @@
 import os
 from fastapi import HTTPException, Security
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import sys
 
 security = HTTPBearer()
 
-# Загружаем список валидных ключей из секретов
-# Формат: "key1,key2,key3" или можно JSON
-VALID_KEYS_STR = os.getenv("API_KEYS", "")
-VALID_KEYS = set(key.strip() for key in VALID_KEYS_STR.split(",") if key.strip())
+print(f"📁 Looking for .env in: {os.path.abspath('.')}", flush=True)
+print(f"📁 .env exists: {os.path.exists('.env')}", flush=True)
+
+# Загружаем ключи из переменной окружения
+API_KEYS_STR = os.getenv("API_KEYS", "")
+
+# Разбираем ключи (поддерживаем разделение запятой)
+VALID_KEYS = set()
+if API_KEYS_STR:
+    for key in API_KEYS_STR.split(","):
+        key = key.strip()
+        if key:
+            VALID_KEYS.add(key)
 
 async def verify_api_key(credentials: HTTPAuthorizationCredentials = Security(security)):
     """
     Проверяет API-ключ, переданный в заголовке Authorization: Bearer <key>.
     """
     provided_key = credentials.credentials
+    print(f"🔑 Received key: '{provided_key}'", flush=True)
+    
     if provided_key not in VALID_KEYS:
+        print(f"❌ Invalid key: '{provided_key}' not in {VALID_KEYS}", flush=True)
         raise HTTPException(status_code=403, detail="Invalid or missing API Key")
+    
+    print(f"✅ Valid key: {provided_key}", flush=True)
     return provided_key

app/factory.py

@@ -1,21 +1,27 @@
 from .providers.zhipu import ZhipuFlashProvider
-# from .providers.openai import OpenAIProvider  # на будущее
+from .providers.hf_openai import HFOpenAIProvider
 
 class ProviderFactory:
     _providers = {
         "zhipu-flash": ZhipuFlashProvider,
-        # "openai-gpt3": OpenAIProvider,
+        "arch-router": HFOpenAIProvider,
+        "phi-3-mini": HFOpenAIProvider,
+        "gemma-2-2b": HFOpenAIProvider,
+        "mistral-7b": HFOpenAIProvider,
+        "llama-3.2-3b": HFOpenAIProvider,
+        "qwen2.5-3b": HFOpenAIProvider,
     }
     
     _instances = {}
 
     @classmethod
     def get_provider(cls, model_name: str):
-        # Используем полное имя модели как ключ
         if model_name not in cls._providers:
             raise ValueError(f"Unsupported model/provider: {model_name}")
         
-        if model_name not in cls._instances:
-            cls._instances[model_name] = cls._providers[model_name]()
+        provider_class = cls._providers[model_name]
+        cache_key = provider_class.__name__
+        if cache_key not in cls._instances:
+            cls._instances[cache_key] = provider_class()
         
-        return cls._instances[model_name]
+        return cls._instances[cache_key]

app/main.py

@@ -1,12 +1,14 @@
 import os
 import sys
-from fastapi import FastAPI, Depends, HTTPException
-from typing import List, Optional, Dict, Any
+from dotenv import load_dotenv
 
 # Отключаем буферизацию вывода сразу при старте
 sys.stdout.reconfigure(line_buffering=True)
 print("🚀 Starting application initialization...", flush=True)
 
+load_dotenv()
+
+from fastapi import FastAPI, Depends, HTTPException
 from .auth import verify_api_key
 from .factory import ProviderFactory
 from .models import ChatRequest, ChatResponse
@@ -21,11 +23,15 @@ async def root():
 
 @app.get("/v1/models")
 async def list_models(api_key: str = Depends(verify_api_key)):
-    """Возвращает список доступных моделей/провайдеров."""
-    print("📋 Models endpoint accessed", flush=True)
     return {
         "models": [
-            {"id": "zhipu-flash", "name": "GLM-4.7-Flash", "provider": "zhipu", "type": "free"},
+            {"id": "zhipu-flash", "name": "GLM-4.7-Flash (Zhipu)", "provider": "zhipu", "type": "free"},
+            {"id": "arch-router", "name": "Arch Router 1.5B (HF)", "provider": "huggingface", "type": "free"},
+            {"id": "phi-3-mini", "name": "Phi-3 Mini 4K (HF)", "provider": "huggingface", "type": "free"},
+            {"id": "gemma-2-2b", "name": "Gemma 2 2B (HF)", "provider": "huggingface", "type": "free"},
+            {"id": "mistral-7b", "name": "Mistral 7B (HF)", "provider": "huggingface", "type": "free"},
+            {"id": "llama-3.2-3b", "name": "Llama 3.2 3B (HF)", "provider": "huggingface", "type": "free"},
+            {"id": "qwen2.5-3b", "name": "Qwen 2.5 3B (HF)", "provider": "huggingface", "type": "free"},
         ]
     }
 
@@ -67,7 +73,8 @@ async def chat_completion(
         print(f"❌ ValueError: {e}", flush=True)
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
-        print(f"❌ Exception: {type(e).__name__}: {e}", flush=True)
         import traceback
-        traceback.print_exc()
+        error_trace = traceback.format_exc()
+        print(f"❌ Exception: {type(e).__name__}: {e}", flush=True)
+        print(f"❌ Traceback: {error_trace}", flush=True)
         raise HTTPException(status_code=502, detail=f"Provider error: {str(e)}")

app/providers/hf_openai.py

@@ -0,0 +1,66 @@
+import os
+from openai import AsyncOpenAI
+from typing import List, Dict, Any
+from .base import BaseLLMProvider
+
+class HFOpenAIProvider(BaseLLMProvider):
+    """Провайдер для Hugging Face через OpenAI-совместимый API"""
+    
+    SUPPORTED_MODELS = {
+        "arch-router": "katanemo/Arch-Router-1.5B:hf-inference",
+        "phi-3-mini": "microsoft/Phi-3-mini-4k-instruct:hf-inference",
+        "gemma-2-2b": "google/gemma-2-2b-it:hf-inference",
+        "mistral-7b": "mistralai/Mistral-7B-Instruct-v0.3:hf-inference",
+        "llama-3.2-3b": "meta-llama/Llama-3.2-3B-Instruct:hf-inference",
+        "qwen2.5-3b": "Qwen/Qwen2.5-3B-Instruct:hf-inference",
+    }
+    
+    def __init__(self):
+        self.api_key = os.getenv("HF_API_KEY")
+        if not self.api_key:
+            raise ValueError("HF_API_KEY not set in environment variables")
+        
+        self.client = AsyncOpenAI(
+            base_url="https://router.huggingface.co/v1",
+            api_key=self.api_key
+        )
+        print(f"🤗 HF OpenAI Provider initialized", flush=True)
+    
+    def _get_model_id(self, model_name: str) -> str:
+        """Получает полный ID модели с провайдером"""
+        if model_name in self.SUPPORTED_MODELS:
+            return self.SUPPORTED_MODELS[model_name]
+        # По умолчанию
+        return "katanemo/Arch-Router-1.5B:hf-inference"
+    
+    async def generate(self, messages: List[Dict[str, str]], **kwargs):
+        """Генерация ответа через OpenAI-совместимый API HF"""
+        model_name = kwargs.get("model", "arch-router")
+        model_id = self._get_model_id(model_name)
+        
+        try:
+            print(f"🚀 Sending request to HF OpenAI with model {model_id}", flush=True)
+            
+            response = await self.client.chat.completions.create(
+                model=model_id,
+                messages=messages,
+                max_tokens=kwargs.get("max_tokens", 500),
+                temperature=kwargs.get("temperature", 0.7),
+                top_p=kwargs.get("top_p", 0.95)
+            )
+            
+            print(f"✅ Received response", flush=True)
+            
+            return {
+                "content": response.choices[0].message.content,
+                "total_tokens": response.usage.total_tokens if response.usage else 0,
+                "model": model_id
+            }
+            
+        except Exception as e:
+            print(f"❌ Error in HF OpenAI provider: {e}", flush=True)
+            raise
+    
+    async def generate_stream(self, messages: List[Dict[str, str]], **kwargs):
+        """Стриминг пока не реализован"""
+        raise NotImplementedError("Streaming not implemented")

app/providers/huggingface.py

@@ -0,0 +1,218 @@
+import os
+import httpx
+import json
+from typing import List, Dict, Any, Optional
+from .base import BaseLLMProvider
+import sys
+
+class HuggingFaceProvider(BaseLLMProvider):
+    """Провайдер для Hugging Face Serverless Inference API"""
+    
+    # Словарь с информацией о поддерживаемых моделях
+    SUPPORTED_MODELS = {
+        "phi-3-mini": {
+            "model_id": "microsoft/Phi-3-mini-4k-instruct",
+            "max_tokens": 4096,
+            "description": "Microsoft Phi-3 Mini (3.8B) - очень быстрая",
+            "type": "free"
+        },
+        "mistral-7b": {
+            "model_id": "mistralai/Mistral-7B-Instruct-v0.3",
+            "max_tokens": 8192,
+            "description": "Mistral 7B Instruct - качественная базовая модель",
+            "type": "free"
+        },
+        "gemma-2-2b": {
+            "model_id": "google/gemma-2-2b-it",
+            "max_tokens": 8192,
+            "description": "Google Gemma 2 2B - быстрая и легкая",
+            "type": "free"
+        },
+        "llama-3.2-1b": {
+            "model_id": "meta-llama/Llama-3.2-1B-Instruct",
+            "max_tokens": 131072,
+            "description": "Meta Llama 3.2 1B - сверхбыстрая",
+            "type": "free"
+        },
+        "llama-3.2-3b": {
+            "model_id": "meta-llama/Llama-3.2-3B-Instruct",
+            "max_tokens": 131072,
+            "description": "Meta Llama 3.2 3B - баланс скорости и качества",
+            "type": "free"
+        },
+        "qwen2.5-3b": {
+            "model_id": "Qwen/Qwen2.5-3B-Instruct",
+            "max_tokens": 32768,
+            "description": "Qwen 2.5 3B - хорошая поддержка русского",
+            "type": "free"
+        },
+        "ru-mistral": {
+            "model_id": "AlexWortega/ruMistral-7B-Instruct",
+            "max_tokens": 8192,
+            "description": "Русскоязычный Mistral 7B",
+            "type": "free"
+        }
+    }
+    
+    def __init__(self):
+        self.api_key = os.getenv("HF_API_KEY")
+        if not self.api_key:
+            print("⚠️ HF_API_KEY not set, will use without authentication (rate limits apply)", flush=True)
+            self.api_key = None
+        self.base_url = "https://router.huggingface.co/hf/v1"
+        print(f"🤗 HuggingFaceProvider initialized, API key: {'✅' if self.api_key else '❌'}", flush=True)
+    
+    def _get_model_id(self, model_name: str) -> str:
+        """Получает реальный ID модели из HF по короткому имени"""
+        if model_name in self.SUPPORTED_MODELS:
+            return self.SUPPORTED_MODELS[model_name]["model_id"]
+        # Если передан полный HF ID, используем его
+        if "/" in model_name:
+            return model_name
+        # По умолчанию
+        return "microsoft/Phi-3-mini-4k-instruct"
+    
+    async def generate(self, messages: List[Dict[str, str]], **kwargs):
+        """Генерация ответа через HF Inference API - РАБОЧАЯ ВЕРСИЯ ДЛЯ GEMMA"""
+        model_name = kwargs.get("model", "phi-3-mini")
+        model_id = self._get_model_id(model_name)  # Предполагаем, что тут будет "google/gemma-2-2b-it"
+
+        # Берем последнее сообщение пользователя
+        user_message = ""
+        for msg in messages:
+            if msg["role"] == "user":
+                user_message = msg["content"]
+                break
+
+        if not user_message:
+            user_message = "Hello"
+
+        # Gemma 2 instruct требует особого формата промпта для чата [citation:6]
+        # <bos><start_of_turn>user\n{user_message}<end_of_turn>\n<start_of_turn>model\n
+        prompt = f"<bos><start_of_turn>user\n{user_message}<end_of_turn>\n<start_of_turn>model\n"
+
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        headers["Content-Type"] = "application/json"
+
+        # ПРАВИЛЬНЫЙ URL для бесплатного Inference API
+        url = f"https://api-inference.huggingface.co/models/{model_id}"
+        print(f"🚀 Sending to URL: {url}", flush=True)
+        print(f"📝 Prompt: {prompt}", flush=True)
+
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": kwargs.get("max_tokens", 500),
+                "temperature": kwargs.get("temperature", 0.7),
+                "top_p": kwargs.get("top_p", 0.95),
+                "do_sample": True,
+                "return_full_text": False  # Не возвращать промпт в ответе
+            }
+        }
+
+        async with httpx.AsyncClient() as client:
+            try:
+                resp = await client.post(
+                    url,
+                    json=payload,
+                    headers=headers,
+                    timeout=60.0
+                )
+
+                print(f"📥 Response status: {resp.status_code}", flush=True)
+
+                if resp.status_code == 200:
+                    data = resp.json()
+                    print(f"📦 Response data: {str(data)[:200]}...", flush=True)
+
+                    # Парсим ответ от Gemma (он приходит в виде списка)
+                    if isinstance(data, list) and len(data) > 0:
+                        if "generated_text" in data[0]:
+                            # Ответ модели уже содержит продолжение, нам не нужен промпт
+                            generated_text = data[0]["generated_text"]
+                            return {
+                                "content": generated_text,
+                                "total_tokens": kwargs.get("max_tokens", 500),
+                                "model": model_id
+                            }
+                    return {
+                        "content": "Не удалось распарсить ответ модели.",
+                        "total_tokens": 0,
+                        "model": model_id
+                    }
+                elif resp.status_code == 503:
+                    return {
+                        "content": "⏳ Модель загружается (холодный старт), попробуйте через несколько секунд...",
+                        "total_tokens": 0,
+                        "model": model_id
+                    }
+                else:
+                    error_text = resp.text
+                    print(f"❌ Error: {resp.status_code} - {error_text}", flush=True)
+                    return {
+                        "content": f"Error: {resp.status_code}",
+                        "total_tokens": 0,
+                        "model": model_id
+                    }
+
+            except Exception as e:
+                print(f"❌ Exception: {e}", flush=True)
+                return {
+                    "content": f"Error: {str(e)}",
+                    "total_tokens": 0,
+                    "model": model_id
+                }
+    
+    def _format_messages(self, messages: List[Dict[str, str]], model_id: str) -> str:
+        """Форматирует сообщения в промпт для конкретной модели"""
+        # Простая реализация - берем последнее сообщение пользователя
+        # В реальном проекте нужно делать под каждый формат модели
+        last_user_msg = None
+        system_msg = None
+        
+        for msg in messages:
+            if msg["role"] == "user":
+                last_user_msg = msg["content"]
+            elif msg["role"] == "system":
+                system_msg = msg["content"]
+        
+        if not last_user_msg:
+            last_user_msg = "Hello"
+        
+        # Форматируем в зависимости от модели
+        if "phi" in model_id.lower():
+            # Phi-3 формат
+            prompt = f"<|user|>\n{last_user_msg}\n<|assistant|>\n"
+        elif "llama" in model_id.lower():
+            # Llama 3 формат
+            prompt = f"<|start_header_id|>user<|end_header_id|>\n\n{last_user_msg}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+        elif "gemma" in model_id.lower():
+            # Gemma формат
+            prompt = f"<start_of_turn>user\n{last_user_msg}<end_of_turn>\n<start_of_turn>model\n"
+        else:
+            # Универсальный формат
+            prompt = last_user_msg
+        
+        return prompt
+    
+    def _extract_response(self, data: Any) -> str:
+        """Извлекает текст ответа из разных форматов HF"""
+        try:
+            if isinstance(data, list) and len(data) > 0:
+                if isinstance(data[0], dict) and "generated_text" in data[0]:
+                    return data[0]["generated_text"]
+            elif isinstance(data, dict):
+                if "generated_text" in data:
+                    return data["generated_text"]
+            
+            # Если ничего не нашли, возвращаем как строку
+            return str(data)
+        except Exception as e:
+            print(f"❌ Error extracting response: {e}", flush=True)
+            return str(data)
+    
+    async def generate_stream(self, messages: List[Dict[str, str]], **kwargs):
+        """Стриминг пока не поддерживается"""
+        raise NotImplementedError("Streaming not implemented for HuggingFace provider")

requirements.txt

@@ -2,4 +2,7 @@ fastapi==0.115.0
 uvicorn[standard]==0.30.0
 httpx==0.27.0
 pydantic==2.7.0
-python-multipart==0.0.9
+python-multipart==0.0.9
+httpx==0.27.0
+python-dotenv==1.0.0
+openai>=1.0.0

start.bat

@@ -0,0 +1,3 @@
+@echo off
+call venv\Scripts\activate
+uvicorn app.main:app --reload --host 127.0.0.1 --port 8000