Додано підтримку кількох провайдерів API (OpenRouter та Anthropic) в аналізаторі НПА. Оновлено інтерфейс для вибору провайдера та моделі, а також перевірки наявності API ключів. Внесено зміни в логіку аналізу та форматування результатів. Додано нові функції для зміни провайдера та моделі.

app.py

@@ -3,20 +3,23 @@ import sys
 from src.interface import create_interface
 
 if __name__ == "__main__":
-    # Перевірка наявності API ключа
-    if not os.getenv('ANTHROPIC_API_KEY'):
-        print("Помилка: Змінна середовища ANTHROPIC_API_KEY не встановлена.")
-        print("Будь ласка, встановіть її перед запуском.")
-        print("Наприклад: export ANTHROPIC_API_KEY=your-api-key")
+    # Перевірка наявності API ключа (OpenRouter або Anthropic)
+    if not os.getenv('OPENROUTER_API_KEY') and not os.getenv('ANTHROPIC_API_KEY'):
+        print("Помилка: Жоден з API ключів не встановлено.")
+        print("Будь ласка, встановіть хоча б один ключ перед запуском:")
+        print("Наприклад: export OPENROUTER_API_KEY=your-api-key")
+        print("Або: export ANTHROPIC_API_KEY=your-api-key")
         sys.exit(1)
     
     try:
-        print("Запуск аналізатора НПА з режимом 'extended thinking'")
+        print("Запуск аналізатора НПА")
         print("=======================================================")
         print("Доступні налаштування в інтерфейсі:")
-        print("1. Увімкнути/вимкнути режим роздумів")
-        print("2. Налаштувати бюджет токенів для роздумів (1024-8000)")
-        print("3. Вибрати чи відображати роздуми моделі в інтерфейсі")
+        print("1. Вибір провайдера (OpenRouter, Anthropic)")
+        print("2. Вибір моделі в межах провайдера")
+        print("3. Увімкнення режиму роздумів (якщо підтримується)")
+        print("4. Налаштування бюджету токенів для роздумів (1024-8000)")
+        print("5. Вибір чи відображати роздуми моделі в інтерфейсі")
         print("=======================================================")
         
         # Створення та запуск інтерфейсу

requirements.txt

@@ -1,3 +1,4 @@
 anthropic==0.47.1
 gradio>=4.44.1
-python-dotenv>=1.0.0
+python-dotenv>=1.0.0
+openai>=1.0.0

src/analyzer.py

@@ -1,30 +1,32 @@
 import os
-import anthropic
-import pkg_resources
-from .prompts import SYSTEM_PROMPT, get_analysis_prompt
+from .llm_providers import get_provider, get_available_providers
+from .prompts import get_analysis_prompt
 
 
 class NPAAnalyzer:
-    def __init__(self):
+    def __init__(self, provider_name="openrouter", model=None):
         self.base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         self.methodology_path = os.path.join(self.base_dir, 'data', 'methodology.txt')
 
-        api_key = os.getenv('ANTHROPIC_API_KEY')
-        if not api_key:
-            raise ValueError("API key not found in environment variables")
-        
-        # Створення клієнта Anthropic
-        self.client = anthropic.Anthropic(api_key=api_key)
-        
-        # Отримання версії бібліотеки
+        # Ініціалізація провайдера
         try:
-            anthropic_version = pkg_resources.get_distribution("anthropic").version
-            print(f"Використовується Anthropic SDK версії: {anthropic_version}")
-            # Ми вважаємо, що версія 0.47.1 або вище підтримує thinking
-            self.supports_thinking = True
-        except:
-            print("Не вдалося визначити версію Anthropic SDK")
-            self.supports_thinking = True  # Припускаємо, що підтримується, бо SDK оновлено
+            self.provider = get_provider(provider_name, model=model)
+            print(f"Використовується провайдер: {self.provider.name}, модель: {model or 'за замовчуванням'}")
+        except ValueError as e:
+            print(f"Помилка при ініціалізації провайдера: {str(e)}")
+            print("Спроба ініціалізації OpenRouter...")
+            
+            try:
+                # Спроба OpenRouter
+                self.provider = get_provider("openrouter")
+                print(f"Успішно ініціалізовано OpenRouter")
+            except ValueError as e:
+                print(f"Помилка при ініціалізації OpenRouter: {str(e)}")
+                print("Спроба ініціалізації Anthropic...")
+                
+                # Спроба Anthropic
+                self.provider = get_provider("anthropic")
+                print(f"Успішно ініціалізовано Anthropic")
             
         self.methodology = self._load_methodology()
         print(f"Методологія завантажена, розмір: {len(self.methodology)} символів")
@@ -46,11 +48,10 @@ class NPAAnalyzer:
     def analyze_npa(self, npa_text: str, enable_thinking=False, thinking_budget=2000) -> dict:
         """
         Аналізує нормативно-правовий акт і повертає словник з текстом відповіді та роздумами.
-        Використовує потокову передачу даних для довгих запитів.
         
         Args:
             npa_text (str): Текст НПА для аналізу
-            enable_thinking (bool): Чи включати режим "thinking" (за замовчуванням True)
+            enable_thinking (bool): Чи включати режим "thinking" (за замовчуванням False)
             thinking_budget (int): Бюджет токенів для режиму "thinking" (за замовчуванням 2000)
             
         Returns:
@@ -60,95 +61,58 @@ class NPAAnalyzer:
             return {"response": "Будь ласка, введіть текст НПА для аналізу.", "thinking": None}
 
         try:
-            # Підготовка повідомлення користувача
-            user_message = {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": get_analysis_prompt(self.methodology, npa_text)
-                    }
-                ]
-            }
-            
-            # Спільні параметри запиту (без stream, оскільки він вже є в messages.stream())
-            params = {
-                "model": "claude-3-7-sonnet-20250219",
-                "max_tokens": 16000,
-                "system": "Ти - експерт з антикорупційної експертизи нормативно-правових актів.",
-                "messages": [user_message]
-            }
-            
-            # Додавання параметра thinking, якщо дозволено і підтримується
-            if enable_thinking and self.supports_thinking:
-                print(f"Використовуємо параметр thinking при запиті з бюджетом: {thinking_budget} токенів")
-                params["thinking"] = {
-                    "type": "enabled",
-                    "budget_tokens": thinking_budget
-                }
-            else:
-                print("Режим thinking вимкнено або не підтримується")
-            
-            # Підготовка результату
-            result = {
-                "response": "",  # Основна відповідь (text блок)
-                "thinking": ""   # Блок "роздумів" (thinking блок)
-            }
+            # Підготовка промпту
+            analysis_prompt = get_analysis_prompt(self.methodology, npa_text)
             
-            # Виконання запиту з потоковою передачею (без додаткового параметра stream)
-            with self.client.messages.stream(**params) as stream:
-                for event in stream:
-                    if event.type == "content_block_delta":
-                        if event.delta.type == "text_delta":
-                            # Додаємо частину тексту до відповіді
-                            result["response"] += event.delta.text
-                        elif event.delta.type == "thinking_delta":
-                            # Додаємо частину мислення до блоку thinking
-                            result["thinking"] += event.delta.thinking
+            # Використовуємо відповідний провайдер для аналізу
+            # Якщо провайдер не підтримує thinking, але enable_thinking=True, то це буде проігноровано
+            result = self.provider.analyze(
+                prompt=analysis_prompt,
+                enable_thinking=enable_thinking and self.provider.supports_thinking,
+                thinking_budget=thinking_budget
+            )
             
-            # Якщо відповідь порожня, але є "роздуми"
-            if not result["response"] and result["thinking"]:
-                result["response"] = "Не вдалося отримати текстову відповідь, але доступні роздуми моделі."
-            elif not result["response"] and not result["thinking"]:
-                result["response"] = "Не вдалося отримати відповідь від моделі."
-                
             return result
                 
         except Exception as e:
             error_message = str(e)
             print(f"Помилка при аналізі: {error_message}")
-            
-            # Якщо помилка пов'язана зі streaming, спробуємо без нього
-            if "streaming" in error_message.lower() or "stream" in error_message.lower():
-                print("Спроба виконати запит без потокової передачі")
-                try:
-                    # Виконання запиту без streaming
-                    response = self.client.messages.create(**params)
-                    
-                    # Підготовка результату
-                    result = {
-                        "response": None,  # Основна відповідь (text блок)
-                        "thinking": None   # Блок "роздумів" (thinking блок)
-                    }
-                    
-                    # Обробка відповіді
-                    if hasattr(response, 'content') and isinstance(response.content, list):
-                        for content_block in response.content:
-                            if hasattr(content_block, 'type') and content_block.type == 'text':
-                                if hasattr(content_block, 'text'):
-                                    result["response"] = content_block.text
-                            elif hasattr(content_block, 'type') and content_block.type == 'thinking':
-                                if hasattr(content_block, 'thinking'):
-                                    if result["thinking"] is not None:
-                                        result["thinking"] += "\n\n" + content_block.thinking
-                                    else:
-                                        result["thinking"] = content_block.thinking
-                    
-                    if not result["response"]:
-                        result["response"] = "Не вдалося отримати текстову відповідь від моделі."
-                    
-                    return result
-                except Exception as e2:
-                    return {"response": f"Помилка при аналізі: {str(e2)}", "thinking": None}
-            
-            return {"response": f"Помилка при аналізі: {error_message}", "thinking": None}
+            return {"response": f"Помилка при аналізі: {error_message}", "thinking": None}
+    
+    def get_available_models(self):
+        """Повертає список доступних моделей для поточного провайдера"""
+        return self.provider.available_models
+    
+    def get_provider_name(self):
+        """Повертає назву поточного провайдера"""
+        return self.provider.name
+    
+    def supports_thinking(self):
+        """Повертає True, якщо поточний провайдер підтримує режим роздумів"""
+        return self.provider.supports_thinking
+    
+    @staticmethod
+    def get_available_providers():
+        """Повертає список доступних провайдерів"""
+        return get_available_providers()
+    
+    def change_provider(self, provider_name, model=None):
+        """Змінює поточного провайдера"""
+        try:
+            self.provider = get_provider(provider_name, model=model)
+            print(f"Провайдера змінено на: {self.provider.name}, модель: {model or 'за замовчуванням'}")
+            return True
+        except Exception as e:
+            print(f"Помилка при зміні провайдера: {str(e)}")
+            return False
+    
+    def change_model(self, model):
+        """Змінює модель для поточного провайдера"""
+        try:
+            current_provider_name = self.provider.name
+            self.provider = get_provider(current_provider_name, model=model)
+            print(f"Модель змінено на: {model}")
+            return True
+        except Exception as e:
+            print(f"Помилка при зміні моделі: {str(e)}")
+            return False

src/interface.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import time
+import os
 from .analyzer import NPAAnalyzer
 
 # Кольори сайту НАЗК
@@ -13,62 +14,112 @@ NAZK_DARK_TEXT = "#333333"
 
 def create_interface():
     try:
-        analyzer = NPAAnalyzer()
+        # Ініціалізація аналізатора з OpenRouter за замовчуванням
+        analyzer = NPAAnalyzer(provider_name="openrouter")
+        
+        # Отримання доступних провайдерів та моделей
+        available_providers = analyzer.get_available_providers()
+        available_models = analyzer.get_available_models()
+        
+        # Перевірка наявності API ключів
+        has_anthropic_key = bool(os.getenv('ANTHROPIC_API_KEY'))
+        has_openrouter_key = bool(os.getenv('OPENROUTER_API_KEY'))
+        
+        if not has_anthropic_key and not has_openrouter_key:
+            raise ValueError("Жоден з API ключів (ANTHROPIC_API_KEY, OPENROUTER_API_KEY) не встановлено")
+            
+        if not has_openrouter_key and analyzer.get_provider_name() == "OpenRouter":
+            # Використовуємо Anthropic, якщо OpenRouter не доступний
+            if has_anthropic_key:
+                analyzer.change_provider("anthropic")
+                print("Ключ OpenRouter відсутній, використовується Anthropic")
+            else:
+                raise ValueError("Відсутній ключ OpenRouter, а Anthropic недоступний")
+
+        # Функція для оновлення доступних моделей при зміні провайдера
+        def update_models(provider_name):
+            analyzer.change_provider(provider_name)
+            new_models = analyzer.get_available_models()
+            supports_thinking = analyzer.supports_thinking()
+            
+            # Оновлення елементів інтерфейсу
+            return gr.Dropdown(choices=new_models, value=new_models[0]), gr.update(interactive=supports_thinking), gr.update(interactive=supports_thinking)
+        
+        # Функція для оновлення моделі
+        def update_model(model_name):
+            analyzer.change_model(model_name)
+            return f"Модель змінено на: {model_name}"
 
         # Функція для форматування результату в Markdown
-        def analyze_and_format(npa_text, enable_thinking, thinking_budget, show_thinking=False, progress=gr.Progress()):
+        def analyze_and_format(npa_text, selected_provider, selected_model, enable_thinking, thinking_budget, progress=gr.Progress()):
             if not npa_text.strip():
                 return "### Помилка\nПоле для тексту не може бути порожнім. Введіть текст для аналізу.", "", "Перевірте введені дані"
 
+            # Переконуємось, що провайдер та модель встановлені правильно
+            if analyzer.get_provider_name() != selected_provider:
+                analyzer.change_provider(selected_provider)
+            
+            current_models = analyzer.get_available_models()
+            if selected_model in current_models:
+                analyzer.change_model(selected_model)
+
             # Перевірка та конвертація бюджету токенів
             try:
                 thinking_budget = int(thinking_budget)
                 if thinking_budget < 1024:
-                    thinking_budget = 1024  # Мінімальний бюджет за документацією
+                    thinking_budget = 1024  # Мінімальний бюджет
                 elif thinking_budget > 8000:
-                    thinking_budget = 8000  # Рекомендований максимум 
+                    thinking_budget = 8000  # Рекомендований максимум
             except (ValueError, TypeError):
                 thinking_budget = 2000  # Значення за замовчуванням
 
-            start_time = time.time()  # Початок відліку часу
+            start_time = time.time()
             
-            # Повідомлення про початок аналізу
+            # Індикатори прогресу
             progress(0, desc="Ініціалізація аналізу...")
-            time.sleep(0.5)  # Невелика затримка для відображення прогресу
+            time.sleep(0.5)
             
             progress(0.1, desc="Підготовка тексту НПА...")
             time.sleep(0.5)
             
-            progress(0.2, desc="Відправка запиту до моделі...")
+            progress(0.2, desc=f"Відправка запиту до {selected_provider}...")
             
-            # Тепер analyze_npa приймає параме��ри enable_thinking та thinking_budget
+            # Аналіз з поточними налаштуваннями
+            supports_thinking = analyzer.supports_thinking()
             result = analyzer.analyze_npa(
                 npa_text, 
-                enable_thinking=enable_thinking, 
+                enable_thinking=(enable_thinking and supports_thinking), 
                 thinking_budget=thinking_budget
             )
             
             progress(0.9, desc="Форматування результатів...")
             
-            end_time = time.time()  # Кінець відліку часу
+            end_time = time.time()
             elapsed_time = end_time - start_time
             
             # Форматування основної відповіді
             formatted_response = f"## Результат аналізу:\n{result['response']}\n\n_Час аналізу: {elapsed_time:.2f} секунд._"
             
-            # Форматування роздумів моделі (якщо є)
+            # Форматування роздумів моделі - показуємо автоматично якщо режим роздумів увімкнено
             thinking_output = ""
-            if show_thinking and result['thinking']:
-                thinking_output = f"## Хід роздумів моделі\n```\n{result['thinking']}\n```"
-            elif show_thinking and not result['thinking']:
-                thinking_output = "## Роздуми моделі недоступні\nРоздуми моделі відсутні або режим думок вимкнено."
-            
-            # Додаємо інформацію про налаштування
-            settings_info = f"\n\n_Налаштування: режим роздумів {'увімкнено' if enable_thinking else 'вимкнено'}"
-            if enable_thinking:
-                settings_info += f", бюджет токенів: {thinking_budget}_"
+            if enable_thinking and supports_thinking:
+                if result['thinking']:
+                    thinking_output = f"## Хід роздумів моделі\n```\n{result['thinking']}\n```"
+                else:
+                    thinking_output = "## Роздуми моделі недоступні\nРоздуми моделі відсутні або виникла помилка при їх отриманні."
             else:
-                settings_info += "_"
+                thinking_output = f"## Роздуми моделі недоступні\n{'Режим роздумів вимкнено.' if supports_thinking else f'Провайдер {selected_provider} не підтримує режим роздумів.'}"
+            
+            # Додавання інформації про налаштування
+            settings_info = f"\n\n_Провайдер: {selected_provider}, Модель: {selected_model}, "
+            if supports_thinking:
+                settings_info += f"режим роздумів {'увімкнено' if enable_thinking else 'вимкнено'}"
+                if enable_thinking:
+                    settings_info += f", бюджет токенів: {thinking_budget}_"
+                else:
+                    settings_info += "_"
+            else:
+                settings_info += "режим роздумів не підтримується_"
             
             formatted_response += settings_info
             
@@ -141,7 +192,7 @@ def create_interface():
         """
 
         with gr.Blocks(css=custom_css) as iface:
-            # Хедер із логотипом (можна замінити на справжній логотип)
+            # Хедер із логотипом
             gr.HTML(f"""
                 <div class="header">
                     <h2 style="margin: 0; color: white; display: flex; justify-content: center; align-items: center;">
@@ -156,10 +207,11 @@ def create_interface():
 
                 ### Інструкція:
                 1. Введіть текст проекту нормативно-правового акту в поле нижче.
-                2. За бажанням, налаштуйте параметри режиму "роздумів" моделі.
-                3. Натисніть кнопку "Аналіз" для запуску аналізу.
-                4. Ознайомтесь із висновком.
-                5. Перегляньте процес "роздумів" моделі на відповідній вкладці.
+                2. Виберіть провайдера та модель для аналізу.
+                3. За бажанням, увімкніть режим "роздумів" моделі (якщо підтримується).
+                4. Натисніть кнопку "Аналіз" для запуску аналізу.
+                5. Ознайомтесь із висновком.
+                6. Перегляньте процес "роздумів" моделі на відповідній вкладці (якщо увімкнено режим роздумів).
             """)
 
             with gr.Row():
@@ -169,6 +221,23 @@ def create_interface():
                     placeholder="Вставте текст проекту нормативно-правового акту для аналізу...",
                 )
             
+            with gr.Row():
+                with gr.Column(scale=1):
+                    provider_dropdown = gr.Dropdown(
+                        choices=available_providers,
+                        value=analyzer.get_provider_name(),
+                        label="Провайдер",
+                        info="Виберіть провайдера для аналізу"
+                    )
+                
+                with gr.Column(scale=1):
+                    model_dropdown = gr.Dropdown(
+                        choices=available_models,
+                        value=available_models[0] if available_models else None,
+                        label="Модель",
+                        info="Виберіть модель для аналізу"
+                    )
+            
             with gr.Row():
                 with gr.Column(scale=2):
                     analyze_button = gr.Button("Аналіз", variant="primary")
@@ -176,7 +245,8 @@ def create_interface():
                     enable_thinking_checkbox = gr.Checkbox(
                         label="Увімкнути режим роздумів",
                         value=False,
-                        info="Дозволяє моделі виконувати покрокові роздуми перед відповіддю"
+                        info="Дозволяє моделі виконувати покрокові роздуми перед відповіддю та показує їх у відповідній вкладці",
+                        interactive=analyzer.supports_thinking()
                     )
                 with gr.Column(scale=1):
                     thinking_budget_slider = gr.Slider(
@@ -186,13 +256,7 @@ def create_interface():
                         step=500,
                         label="Бюджет токенів для роздумів",
                         info="Рекомендований діапазон: 1024-8000",
-                        interactive=False  # Вимкнено, оскільки режим роздумів вимкнено за замовчуванням
-                    )
-                with gr.Column(scale=1):
-                    show_thinking_checkbox = gr.Checkbox(
-                        label="Показати роздуми моделі",
-                        value=False,
-                        info="Відображає процес мислення AI при аналізі"
+                        interactive=False  # Буде активовано при увімкненні режиму роздумів
                     )
 
             with gr.Row():
@@ -205,14 +269,28 @@ def create_interface():
                 with gr.TabItem("Роздуми моделі", id="thinking_tab"):
                     thinking_box = gr.Markdown(label="Хід роздумів моделі")
 
-            # Логіка кнопки
+            # Оновлення моделей при зміні провайдера
+            provider_dropdown.change(
+                update_models,
+                inputs=[provider_dropdown],
+                outputs=[model_dropdown, enable_thinking_checkbox, thinking_budget_slider]
+            )
+            
+            # Оновлення моделі
+            model_dropdown.change(
+                update_model,
+                inputs=[model_dropdown],
+                outputs=[status_box]
+            )
+            
+            # Логіка кнопки аналізу
             analyze_button.click(
                 analyze_and_format,
-                inputs=[input_box, enable_thinking_checkbox, thinking_budget_slider, show_thinking_checkbox],
+                inputs=[input_box, provider_dropdown, model_dropdown, enable_thinking_checkbox, thinking_budget_slider],
                 outputs=[output_box, thinking_box, status_box]
             )
             
-            # Оновлення інтерфейсу при зміні стану чекбоксу "Увімкнути режим роздумів"
+            # Логіка чекбоксу "Увімкнути режим роздумів"
             enable_thinking_checkbox.change(
                 lambda x: gr.update(interactive=x),
                 inputs=[enable_thinking_checkbox],
@@ -230,6 +308,26 @@ def create_interface():
                     - Зменшіть бюджет токенів режиму роздумів
                     - Скоротіть текст документа або розділіть його на частини
                     - Ви��кніть режим роздумів для пришвидшення аналізу
+                    - Спробуйте інший провайдер або модель
+                """)
+            
+            # Інформація про API ключі
+            with gr.Accordion("Налаштування API ключів", open=False):
+                gr.Markdown(f"""
+                    ### Статус API ключів
+                    
+                    - OpenRouter API Key: {'✅ Встановлено' if has_openrouter_key else '❌ Відсутній'}
+                    - Anthropic API Key: {'✅ Встановлено' if has_anthropic_key else '❌ Відсутній'}
+                    
+                    Для роботи з різними провайдерами необхідно встановити відповідні API ключі через змінні середовища:
+                    
+                    ```bash
+                    # Для OpenRouter
+                    export OPENROUTER_API_KEY=your-api-key
+                    
+                    # Для Anthropic
+                    export ANTHROPIC_API_KEY=your-api-key
+                    ```
                 """)
             
             # Футер

src/llm_providers.py

@@ -0,0 +1,362 @@
+import os
+import anthropic
+from abc import ABC, abstractmethod
+from openai import OpenAI
+import requests
+import traceback
+from .prompts import SYSTEM_PROMPT
+
+class LLMProvider(ABC):
+    """Абстрактний базовий клас для LLM провайдерів"""
+    
+    @abstractmethod
+    def analyze(self, prompt: str, enable_thinking: bool = False, thinking_budget: int = 2000) -> dict:
+        """
+        Аналізує текст використовуючи LLM провайдера
+        
+        Args:
+            prompt (str): Текст промпту для аналізу
+            enable_thinking (bool): Чи включати режим "думок" якщо підтримується
+            thinking_budget (int): Бюджет токенів для режиму "думок" якщо підтримується
+            
+        Returns:
+            dict: Словник з ключами 'response' та 'thinking'
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Повертає назву провайдера"""
+        pass
+    
+    @property
+    @abstractmethod
+    def supports_thinking(self) -> bool:
+        """Повертає чи підтримує провайдер режим думок"""
+        pass
+    
+    @property
+    @abstractmethod
+    def available_models(self) -> list:
+        """Повертає список доступних моделей для цього провайдера"""
+        pass
+    
+    @abstractmethod
+    def test_connection(self) -> bool:
+        """Перевіряє з'єднання з провайдером"""
+        pass
+
+
+class AnthropicProvider(LLMProvider):
+    """Реалізація провайдера Anthropic"""
+    
+    def __init__(self, api_key=None, model="claude-3-7-sonnet-latest"):
+        """Ініціалізація провайдера Anthropic"""
+        self._api_key = api_key or os.getenv('ANTHROPIC_API_KEY')
+        if not self._api_key:
+            raise ValueError("ANTHROPIC_API_KEY не знайдено в змінних середовища")
+        
+        self.client = anthropic.Anthropic(api_key=self._api_key)
+        self._model = model
+    
+    @property
+    def name(self) -> str:
+        return "Anthropic"
+    
+    @property
+    def supports_thinking(self) -> bool:
+        return True
+    
+    @property
+    def available_models(self) -> list:
+        return [
+            "claude-3-7-sonnet-latest",
+            "claude-3-5-haiku-latest"
+        ]
+    
+    def test_connection(self) -> bool:
+        """Перевіряє з'єднання з Anthropic"""
+        try:
+            # Виконуємо простий тестовий запит
+            response = self.client.messages.create(
+                model=self._model,
+                max_tokens=200,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": "Привіт"
+                    }
+                ]
+            )
+            return True
+        except Exception as e:
+            print(f"Помилка з'єднання з Anthropic: {str(e)}")
+            return False
+    
+    def analyze(self, prompt: str, enable_thinking: bool = False, thinking_budget: int = 2000) -> dict:
+        """Аналізує текст використовуючи Anthropic Claude"""
+        if not prompt:
+            return {"response": "Будь ласка, введіть текст для аналізу.", "thinking": None}
+
+        try:
+            # Підготовка повідомлення користувача
+            user_message = {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": prompt
+                    }
+                ]
+            }
+            
+            # Спільні параметри запиту
+            params = {
+                "model": self._model,
+                "max_tokens": 16000,
+                "system": SYSTEM_PROMPT,
+                "messages": [user_message]
+            }
+            
+            # Додавання параметра thinking, якщо дозволено
+            if enable_thinking:
+                params["thinking"] = {
+                    "type": "enabled",
+                    "budget_tokens": thinking_budget
+                }
+            
+            result = {
+                "response": "",
+                "thinking": ""
+            }
+            
+            # Виконання запиту з потоковою передачею
+            with self.client.messages.stream(**params) as stream:
+                for event in stream:
+                    if event.type == "content_block_delta":
+                        if event.delta.type == "text_delta":
+                            result["response"] += event.delta.text
+                        elif event.delta.type == "thinking_delta":
+                            result["thinking"] += event.delta.thinking
+            
+            # Обробка порожньої відповіді
+            if not result["response"] and result["thinking"]:
+                result["response"] = "Не вдалося отримати текстову відповідь, але доступні роздуми моделі."
+            elif not result["response"] and not result["thinking"]:
+                result["response"] = "Не вдалося отримати відповідь від моделі."
+                
+            return result
+                
+        except Exception as e:
+            error_message = str(e)
+            print(f"Помилка при аналізі (Anthropic): {error_message}")
+            print(f"Деталі помилки: {traceback.format_exc()}")
+            
+            # Якщо помилка пов'язана зі streaming, спробуємо без нього
+            if "streaming" in error_message.lower() or "stream" in error_message.lower():
+                try:
+                    # Виконання запиту без streaming
+                    response = self.client.messages.create(**params)
+                    
+                    result = {
+                        "response": None,
+                        "thinking": None
+                    }
+                    
+                    # Обробка відповіді
+                    if hasattr(response, 'content') and isinstance(response.content, list):
+                        for content_block in response.content:
+                            if hasattr(content_block, 'type') and content_block.type == 'text':
+                                if hasattr(content_block, 'text'):
+                                    result["response"] = content_block.text
+                            elif hasattr(content_block, 'type') and content_block.type == 'thinking':
+                                if hasattr(content_block, 'thinking'):
+                                    if result["thinking"] is not None:
+                                        result["thinking"] += "\n\n" + content_block.thinking
+                                    else:
+                                        result["thinking"] = content_block.thinking
+                    
+                    if not result["response"]:
+                        result["response"] = "Не вдалося отримати текстову відповідь від моделі."
+                    
+                    return result
+                except Exception as e2:
+                    print(f"Помилка при спробі без streaming: {str(e2)}")
+                    print(f"Деталі помилки: {traceback.format_exc()}")
+                    return {"response": f"Помилка при аналізі: {str(e2)}", "thinking": None}
+            
+            return {"response": f"Помилка при аналізі: {error_message}", "thinking": None}
+
+
+class OpenRouterProvider(LLMProvider):
+    """Реалізація провайдера OpenRouter"""
+    
+    def __init__(self, api_key=None, model="openrouter/quasar-alpha"):
+        """Ініціалізація провайдера OpenRouter"""
+        self._api_key = api_key or os.getenv('OPENROUTER_API_KEY')
+        if not self._api_key:
+            raise ValueError("OPENROUTER_API_KEY не знайдено в змінних середовища")
+        
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=self._api_key
+        )
+        self._model = model
+    
+    @property
+    def name(self) -> str:
+        return "OpenRouter"
+    
+    @property
+    def supports_thinking(self) -> bool:
+        return False
+    
+    @property
+    def available_models(self) -> list:
+        return [
+            "openrouter/quasar-alpha",
+            # "google/gemini-2.5-pro-preview-03-25",
+            # "deepseek/deepseek-v3-base:free",
+            # "mistralai/mistral-large",
+            # "meta-llama/llama-3-70b-instruct"
+        ]
+    
+    def test_connection(self) -> bool:
+        """Перевіряє з'єднання з провайдером"""
+        try:
+            # Виконуємо простий тестовий запит
+            completion = self.client.chat.completions.create(
+                extra_headers={
+                    "HTTP-Referer": "https://npa-analyzer.com",
+                    "X-Title": "NPA Analysis Assistant",
+                },
+                model=self._model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": "Привіт"
+                    }
+                ],
+                max_tokens=200
+            )
+            return True
+        except Exception as e:
+            print(f"Помилка з'єднання з OpenRouter: {str(e)}")
+            return False
+    
+    def analyze(self, prompt: str, enable_thinking: bool = False, thinking_budget: int = 2000) -> dict:
+        """Аналізує текст використовуючи OpenRouter"""
+        if not prompt:
+            return {"response": "Будь ласка, введіть текст для аналізу.", "thinking": None}
+
+        try:
+            # Create completion
+            completion = self.client.chat.completions.create(
+                extra_headers={
+                    "HTTP-Referer": "https://npa-analyzer.com",
+                    "X-Title": "NPA Analysis Assistant",
+                },
+                extra_body={},  # Додаємо підтримку extra_body
+                model=self._model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": SYSTEM_PROMPT
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                temperature=0.5,  # Додаємо контроль над температурою для кращих результатів
+                max_tokens=16000,   # Збільшуємо ліміт токенів для аналізу довгих НПА
+                timeout=120        # Збільшуємо таймаут для довгих запитів
+            )
+            
+            # Extract response content with improved error handling
+            if completion and hasattr(completion, 'choices') and completion.choices:
+                if hasattr(completion.choices[0], 'message') and hasattr(completion.choices[0].message, 'content'):
+                    response_content = completion.choices[0].message.content
+                else:
+                    response_content = "Отримано відповідь від API, але структура відповіді нестандартна"
+                    print(f"Нестандартна структура відповіді: {str(completion)}")
+            else:
+                response_content = "Не вдалося отримати відповідь від OpenRouter API"
+                print(f"Структура відповіді: {str(completion)}")
+            
+            return {
+                "response": response_content,
+                "thinking": None  # OpenRouter не підтримує режим роздумів
+            }
+                
+        except Exception as e:
+            error_message = str(e)
+            print(f"Помилка при аналізі (OpenRouter): {error_message}")
+            print(f"Деталі помилки: {traceback.format_exc()}")
+            
+            return {"response": f"Помилка при аналізі: {error_message}", "thinking": None}
+
+
+def get_provider(provider_name, api_key=None, model=None):
+    """Функція-фабрика для отримання екземпляра провайдера"""
+    providers = {
+        "anthropic": lambda: AnthropicProvider(api_key=api_key, model=model) if model else AnthropicProvider(api_key=api_key),
+        "openrouter": lambda: OpenRouterProvider(api_key=api_key, model=model) if model else OpenRouterProvider(api_key=api_key)
+    }
+    
+    if provider_name.lower() not in providers:
+        raise ValueError(f"Невідомий провайдер: {provider_name}")
+    
+    return providers[provider_name.lower()]()
+
+
+def get_available_providers():
+    """Повертає список доступних провайдерів"""
+    return ["OpenRouter", "Anthropic"]
+
+
+def get_available_openrouter_models(api_key=None):
+    """
+    Отримує список доступних моделей з API OpenRouter
+    Примітка: цю функцію можна використовувати для динамічного оновлення списку моделей
+    """
+    try:
+        api_key = api_key or os.getenv('OPENROUTER_API_KEY')
+        if not api_key:
+            return []
+            
+        # Запит на отримання доступних моделей
+        response = requests.get(
+            "https://openrouter.ai/api/v1/models",
+            headers={"Authorization": f"Bearer {api_key}"}
+        )
+        
+        if response.status_code == 200:
+            models_data = response.json()
+            if 'data' in models_data and isinstance(models_data['data'], list):
+                return [model["id"] for model in models_data["data"]]
+        return []
+    except Exception as e:
+        print(f"Помилка отримання списку моделей: {str(e)}")
+        return []
+
+
+def test_model(provider_name, model_name):
+    """Тестує доступність конкретної моделі"""
+    try:
+        provider = get_provider(provider_name)
+        original_model = provider._model
+        provider._model = model_name
+        
+        # Перевіряємо доступність моделі простим запитом
+        result = provider.analyze("Це тестовий запит для перевірки моделі.")
+        
+        print(f"Модель {model_name} відповіла: {result['response'][:100]}...")
+        return True
+    except Exception as e:
+        print(f"Помилка при тестуванні моделі {model_name}: {str(e)}")
+        return False
+    finally:
+        if 'provider' in locals() and 'original_model' in locals():
+            provider._model = original_model

test_models.py

@@ -0,0 +1,35 @@
+# test_models.py
+import os
+import sys
+from src.llm_providers import test_model, get_available_openrouter_models
+
+# Вивести всі доступні моделі з OpenRouter (опціонально)
+print("Спроба отримати список моделей з OpenRouter API...")
+models = get_available_openrouter_models()
+if models:
+    print("Доступні моделі OpenRouter:")
+    for idx, model in enumerate(models, 1):
+        print(f"{idx}. {model}")
+else:
+    print("Не вдалося отримати список моделей або список порожній")
+
+# Тестування конкретних моделей
+models_to_test = [
+    ("openrouter", "google/gemini-2.5-pro-preview-03-25")
+    # ("openrouter", "mistralai/mistral-large")
+    # ("openrouter", "openrouter/quasar-alpha"),
+    # ("openrouter", "deepseek/deepseek-v3-base:free"),
+    # ("anthropic", "claude-3-7-sonnet-20250219")
+]
+
+print("\nПочаток тестування моделей:")
+print("="*50)
+
+for provider, model in models_to_test:
+    print(f"\nТестування {provider}/{model}...")
+    success = test_model(provider, model)
+    status = "✅ УСПІШНО" if success else "❌ ПОМИЛКА"
+    print(f"{status} - {provider}/{model}")
+
+print("="*50)
+print("Тестування завершено!")