Clean

app/auth.py

@@ -1,34 +1,13 @@
 import os
 from fastapi import HTTPException, Security
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-import sys
+from fastapi.security import HTTPBearer
 
 security = HTTPBearer()
 
-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(key.strip() for key in API_KEYS_STR.split(",") if key.strip())
 
-# Разбираем ключи (поддерживаем разделение запятой)
-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
+async def verify_api_key(credentials: str = Security(security)):
+    if credentials.credentials not in VALID_KEYS:
+        raise HTTPException(status_code=403, detail="Invalid API Key")
+    return credentials.credentials

app/factory.py

@@ -1,15 +1,13 @@
-from .providers.zhipu import ZhipuFlashProvider
 from .providers.hf_openai import HFOpenAIProvider
 
 class ProviderFactory:
     _providers = {
-        "zhipu-flash": ZhipuFlashProvider,
         "arch-router": HFOpenAIProvider,
         "phi-3-mini": HFOpenAIProvider,
-        "gemma-2-2b": HFOpenAIProvider,
+        "gemma-2b": HFOpenAIProvider,
         "mistral-7b": HFOpenAIProvider,
-        "llama-3.2-3b": HFOpenAIProvider,
-        "qwen2.5-3b": HFOpenAIProvider,
+        "llama-3b": HFOpenAIProvider,
+        "qwen-3b": HFOpenAIProvider,
     }
     
     _instances = {}
@@ -17,7 +15,7 @@ class ProviderFactory:
     @classmethod
     def get_provider(cls, model_name: str):
         if model_name not in cls._providers:
-            raise ValueError(f"Unsupported model/provider: {model_name}")
+            raise ValueError(f"Unsupported model: {model_name}")
         
         provider_class = cls._providers[model_name]
         cache_key = provider_class.__name__

app/main.py

@@ -1,80 +1,55 @@
 import os
 import sys
+from fastapi import FastAPI, Depends, HTTPException
 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
 
 app = FastAPI(title="LLM API Proxy", version="1.0.0")
-print("✅ FastAPI app created", flush=True)
 
 @app.get("/")
 async def root():
-    print("🌐 Root endpoint accessed", flush=True)
-    return {"message": "LLM API Proxy is running", "version": "1.0.1"}
+    return {"message": "LLM API Proxy is running", "version": "1.0.0"}
 
 @app.get("/v1/models")
 async def list_models(api_key: str = Depends(verify_api_key)):
+    """Возвращает список доступных моделей"""
     return {
         "models": [
-            {"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"},
+            {"id": "arch-router", "name": "Arch Router 1.5B (HF)", "provider": "huggingface"},
+            {"id": "phi-3-mini", "name": "Phi-3 Mini 4K (HF)", "provider": "huggingface"},
+            {"id": "gemma-2b", "name": "Gemma 2 2B (HF)", "provider": "huggingface"},
+            {"id": "mistral-7b", "name": "Mistral 7B (HF)", "provider": "huggingface"},
+            {"id": "llama-3b", "name": "Llama 3.2 3B (HF)", "provider": "huggingface"},
+            {"id": "qwen-3b", "name": "Qwen 2.5 3B (HF)", "provider": "huggingface"},
         ]
     }
 
-@app.post("/v1/chat/completions", response_model=ChatResponse)
+@app.post("/v1/chat/completions")
 async def chat_completion(
     request: ChatRequest,
     api_key: str = Depends(verify_api_key)
 ):
-    """Основной эндпоинт для генерации текста."""
-    print(f"💬 Chat completion requested with model: {request.model}", flush=True)
-    
     try:
-        # 1. Получаем провайдера по имени модели из запроса
-        print(f"🔍 Getting provider for model: {request.model}", flush=True)
         provider = ProviderFactory.get_provider(request.model)
-        print(f"✅ Provider obtained: {type(provider).__name__}", flush=True)
-        
-        # 2. Генерируем ответ
-        print("🔄 Calling provider.generate()...", flush=True)
         result = await provider.generate(
-            messages=[m.dict() for m in request.messages],
+            messages=[{"role": m.role, "content": m.content} for m in request.messages],
             max_tokens=request.max_tokens,
             temperature=request.temperature,
             model=request.model
         )
-        print(f"✅ Generation complete, tokens: {result.get('total_tokens', 0)}", flush=True)
         
-        # 3. Возвращаем в стандартном формате
-        response = ChatResponse(
+        return ChatResponse(
             id=f"chat-{hash(str(request.messages))}",
             choices=[{"message": {"content": result["content"]}}],
             usage={"total_tokens": result.get("total_tokens", 0)},
             model=request.model
         )
-        print("✅ Response prepared, sending...", flush=True)
-        return response
-        
     except ValueError as e:
-        print(f"❌ ValueError: {e}", flush=True)
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
-        import traceback
-        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/models.py

@@ -2,14 +2,14 @@ from pydantic import BaseModel
 from typing import List, Optional
 
 class Message(BaseModel):
-    role: str  # "user", "assistant", "system"
+    role: str
     content: str
 
 class ChatRequest(BaseModel):
     model: str
     messages: List[Message]
-    max_tokens: Optional[int] = 1000
-    temperature: Optional[float] = 0.8
+    max_tokens: Optional[int] = 500
+    temperature: Optional[float] = 0.7
 
 class ChatResponse(BaseModel):
     id: str

app/providers/base.py

@@ -1,11 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import List, Dict, Any, AsyncGenerator
+from typing import List, Dict, Any
 
 class BaseLLMProvider(ABC):
     @abstractmethod
     async def generate(self, messages: List[Dict[str, str]], **kwargs) -> Dict[str, Any]:
-        pass
-
-    @abstractmethod
-    async def generate_stream(self, messages: List[Dict[str, str]], **kwargs) -> AsyncGenerator[str, None]:
         pass

app/providers/hf_openai.py

@@ -1,5 +1,5 @@
 import os
-from openai import AsyncOpenAI
+from openai import OpenAI
 from typing import List, Dict, Any
 from .base import BaseLLMProvider
 
@@ -9,58 +9,44 @@ class HFOpenAIProvider(BaseLLMProvider):
     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",
+        "gemma-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",
+        "llama-3b": "meta-llama/Llama-3.2-3B-Instruct:hf-inference",
+        "qwen-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")
+            raise ValueError("HF_API_KEY not set")
         
-        self.client = AsyncOpenAI(
+        self.client = OpenAI(
             base_url="https://router.huggingface.co/v1",
             api_key=self.api_key
         )
-        print(f"🤗 HF OpenAI Provider initialized", flush=True)
+        print(f"🤗 HF OpenAI Provider initialized")
     
     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)
+        model = self._get_model_id(kwargs.get("model", "arch-router"))
         
         try:
-            print(f"🚀 Sending request to HF OpenAI with model {model_id}", flush=True)
-            
-            response = await self.client.chat.completions.create(
-                model=model_id,
+            response = self.client.chat.completions.create(
+                model=model,
                 messages=messages,
                 max_tokens=kwargs.get("max_tokens", 500),
-                temperature=kwargs.get("temperature", 0.7),
-                top_p=kwargs.get("top_p", 0.95)
+                temperature=kwargs.get("temperature", 0.7)
             )
             
-            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
+                "model": model
             }
-            
         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")
+            print(f"❌ Error: {e}")
+            raise

app/providers/huggingface.py

@@ -1,218 +0,0 @@
-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")

app/providers/zhipu.py

@@ -1,52 +0,0 @@
-import os
-import httpx
-from .base import BaseLLMProvider
-
-class ZhipuFlashProvider(BaseLLMProvider):
-    def __init__(self):
-        self.api_key = os.getenv("ZHIPU_API_KEY")
-        if not self.api_key:
-            raise ValueError("ZHIPU_API_KEY not set")
-        self.base_url = "https://open.bigmodel.cn/api/paas/v4/chat/completions"
-
-    def __init__(self):
-        self.api_key = os.getenv("ZHIPU_API_KEY")
-        print(f"🔑 ZHIPU_API_KEY loaded: {'Yes' if self.api_key else 'NO!'}", flush=True)
-        if not self.api_key:
-            raise ValueError("ZHIPU_API_KEY not set!")
-        self.base_url = "https://api.z.ai/api/paas/v4/chat/completions"
-
-    async def generate(self, messages, **kwargs):
-        try:
-            async with httpx.AsyncClient() as client:
-                payload = {
-                    "model": "glm-4.7-flash",
-                    "messages": messages,
-                    "max_tokens": kwargs.get("max_tokens", 1000),
-                    "temperature": kwargs.get("temperature", 0.8)
-                }
-                headers = {
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json"
-                }
-                
-                print(f"🚀 Sending request to Zhipu: {payload}")  # Диагностика
-                resp = await client.post(self.base_url, json=payload, headers=headers, timeout=30.0)
-                print(f"📥 Response status: {resp.status_code}")  # Диагностика
-                print(f"📥 Response body: {resp.text}")  # Диагностика
-                
-                resp.raise_for_status()
-                data = resp.json()
-                
-                return {
-                    "content": data["choices"][0]["message"]["content"],
-                    "total_tokens": data["usage"]["total_tokens"]
-                }
-        except Exception as e:
-            print(f"💥 Error in Zhipu provider: {str(e)}")  # Диагностика
-            print(f"💥 Exception type: {type(e)}")  # Диагностика
-            raise  # Пробрасываем дальше
-
-    async def generate_stream(self, messages, **kwargs):
-        # Для простоты пропускаем, но можно реализовать
-        raise NotImplementedError("Streaming not yet implemented for Zhipu")

requirements.txt

@@ -1,8 +1,6 @@
 fastapi==0.115.0
 uvicorn[standard]==0.30.0
-httpx==0.27.0
 pydantic==2.7.0
-python-multipart==0.0.9
-httpx==0.27.0
 python-dotenv==1.0.0
-openai>=1.0.0
+openai>=1.0.0
+httpx==0.27.0