Підключено Gemini, але потребує агентної роботи

Gradio_UI.py

@@ -1,7 +1,6 @@
 import gradio as gr
 import logging
 from pathlib import Path
-from config import ModelConfig
 from typing import Tuple, List
 
 logger = logging.getLogger(__name__)
@@ -11,24 +10,33 @@ class GradioUI:
         self.agent = agent
         self.file_upload_folder = Path(file_upload_folder)
         self.file_upload_folder.mkdir(exist_ok=True)
-        self.model_config = ModelConfig()
         
     def build_interface(self):
         with gr.Blocks(theme=gr.themes.Soft()) as interface:
-            # Model selection dropdown
+            # Вибір моделі
             with gr.Row():
-                model_choices = self.model_config.get_available_models()
+                model_choices = self.agent.model_initializer.get_available_models()
                 model_dropdown = gr.Dropdown(
                     choices=[f"{key} - {desc}" for key, desc in model_choices],
-                    value=f"{self.model_config.get_default_model()} - {dict(model_choices)[self.model_config.get_default_model()]}",
+                    value=f"{self.agent.model_initializer.config['default_model']} - {dict(model_choices)[self.agent.model_initializer.config['default_model']]}",
                     label="Оберіть модель",
                     info="Оберіть модель для обробки запитів"
                 )
 
             with gr.Row():
+                # Основний чат
                 chatbot = gr.Chatbot(
                     label="Research Assistant",
-                    height=600,
+                    height=400,
+                    show_copy_button=True
+                )
+                
+                # Лог проміжних кроків
+                steps_log = gr.Textbox(
+                    label="Process Steps",
+                    lines=10,
+                    max_lines=20,
+                    interactive=False,
                     show_copy_button=True
                 )
             
@@ -55,15 +63,14 @@ class GradioUI:
                 clear_btn = gr.Button("Очистити")
                 toggle_upload_btn = gr.Button("Завантажити файл")
 
-            # Store conversation state
+            # Зберігання стану
             state = gr.State([])
             file_history = gr.State([])
-            current_model = gr.State(self.model_config.get_default_model())
+            current_model = gr.State(self.agent.model_initializer.config['default_model'])
 
             def change_model(choice):
                 model_key = choice.split(" - ")[0]
-                model_config = self.model_config.get_model_config(model_key)
-                self.agent.update_model(model_config)
+                self.agent.update_model(model_key)
                 return model_key
 
             model_dropdown.change(
@@ -104,38 +111,53 @@ class GradioUI:
                 if files:
                     message += f"\nДоступні файли для аналізу: {', '.join(files)}"
                 chat_history.append((message, None))
-                return "", chat_history
+                return "", chat_history, "Початок обробки запиту...\n"
 
-            def bot_response(chat_history, files):
+            def bot_response(chat_history, files, steps_text):
                 try:
+                    # Оновлюємо лог кроків
+                    steps = []
+                    def step_callback(step_info):
+                        steps.append(f"Step {len(steps)+1}: {step_info}")
+                        return "\n".join(steps)
+                    
+                    # Додаємо callback до агента
+                    self.agent.step_callback = step_callback
+                    
+                    # Обробляємо запит
                     response = self.agent.process_query(
                         chat_history[-1][0],
                         available_files=files if files else None
                     )
+                    
+                    # Оновлюємо історію чату
                     chat_history[-1] = (chat_history[-1][0], response)
-                    return chat_history
+                    
+                    # Повертаємо оновлену історію та лог кроків
+                    return chat_history, "\n".join(steps) + "\n\nОбробку завершено."
                 except Exception as e:
                     logger.error(f"Помилка відповіді: {e}")
-                    chat_history[-1] = (chat_history[-1][0], f"Помилка: {str(e)}")
-                    return chat_history
+                    error_msg = f"Помилка: {str(e)}"
+                    chat_history[-1] = (chat_history[-1][0], error_msg)
+                    return chat_history, steps_text + f"\nПомилка: {str(e)}"
 
             submit_btn.click(
                 user_message,
                 [text_input, state, file_history],
-                [text_input, chatbot]
+                [text_input, chatbot, steps_log]
             ).then(
                 bot_response,
-                [chatbot, file_history],
-                [chatbot]
+                [chatbot, file_history, steps_log],
+                [chatbot, steps_log]
             )
 
             def clear_chat():
-                return [], []
+                return [], [], ""
             
             clear_btn.click(
                 clear_chat,
                 None,
-                [chatbot, file_history],
+                [chatbot, file_history, steps_log],
                 queue=False
             )
 

agent.py

@@ -8,35 +8,127 @@ logger = logging.getLogger(__name__)
 
 class ResearchAgent(CodeAgent):
     """
-    Research-focused agent for scientific literature search and analysis.
-    Inherits from CodeAgent and specializes in academic research tasks.
+    Дослідницький агент для наукового пошуку та аналізу.
     """
     
     def __init__(self, model, tools, **kwargs):
         """
-        Initialize the research agent.
-        
-        Args:
-            model: The language model to use
-            tools: List of available tools
-            **kwargs: Additional arguments passed to CodeAgent
+        Ініціалізація дослідницького агента.
         """
         super().__init__(model=model, tools=tools, **kwargs)
         self.available_tools = {tool.name: tool for tool in tools}
-        logger.info(f"ResearchAgent initialized with tools: {list(self.available_tools.keys())}")
+        self.model_initializer = None
+        self.step_callback = None
+        logger.info(f"ResearchAgent ініціалізовано з інструментами: {list(self.available_tools.keys())}")
 
-    def format_research_report(self, content: Dict[str, Any]) -> str:
+    def _update_steps(self, step_info: str):
+        """Оновлення інформації про кроки"""
+        if self.step_callback:
+            self.step_callback(step_info)
+
+    def run(self, task: str, stream=False, reset=True) -> str:
         """
-        Format research results into a structured report.
-        
-        Args:
-            content (Dict[str, Any]): Research content to format
+        Перевизначений метод run для кращої обробки запитів.
+        """
+        try:
+            self._update_steps("Початок обробки запиту")
+            
+            # Step 1: Web Search
+            self._update_steps("Пошук інформації в інтернеті")
+            search_results = self.available_tools['web_search'](query=task)
+            
+            # Step 2: Формування запиту до моделі
+            prompt = (
+                "As a research assistant, analyze the following information and create a detailed report.\n\n"
+                f"Task: {task}\n\n"
+                f"Search Results:\n{search_results}\n\n"
+                "Create a comprehensive report with references to sources."
+            )
+            
+            self._update_steps("Генерація звіту на основі знайденої інформації")
+            result = self.model(prompt)
             
-        Returns:
-            str: Formatted research report
+            self._update_steps("Форматування фінального звіту")
+            return result
+            
+        except Exception as e:
+            error_msg = f"Error in run method: {str(e)}"
+            logger.error(error_msg)
+            self._update_steps(f"Помилка: {error_msg}")
+            return error_msg
+
+    def process_query(self, query: str, available_files: Optional[List[str]] = None) -> str:
+        """
+        Обробка дослідницького запиту.
+        """
+        try:
+            logger.info(f"Обробка дослідницького запиту: {query}")
+            self._update_steps("Початок обробки запиту")
+            
+            # Виконання запиту
+            result = self.run(
+                task=query,
+                stream=False,
+                reset=True
+            )
+            
+            if not result:
+                self._update_steps("Не отримано результатів")
+                return "Не вдалося отримати результати. Будь ласка, спробуйте переформулювати запит."
+            
+            self._update_steps("Запит успішно оброблено")
+            
+            if isinstance(result, str):
+                return result
+            
+            if isinstance(result, dict):
+                return self.format_research_report(result)
+            
+            return str(result)
+            
+        except Exception as e:
+            error_msg = f"Помилка при обробці запиту: {str(e)}"
+            logger.error(error_msg)
+            self._update_steps(f"Помилка: {error_msg}")
+            return error_msg
+    """
+    Дослідницький агент для наукового пошуку та аналізу.
+    """
+    
+    def __init__(self, model, tools, **kwargs):
+        """
+        Ініціалізація дослідницького агента.
+        """
+        super().__init__(model=model, tools=tools, **kwargs)
+        self.available_tools = {tool.name: tool for tool in tools}
+        self.model_initializer = None
+        logger.info(f"ResearchAgent ініціалізовано з інструментами: {list(self.available_tools.keys())}")
+
+    def run(self, task: str, stream=False, reset=True) -> str:
+        """
+        Перевизначений метод run для кращої обробки запитів.
+        """
+        try:
+            # Формуємо простий текстовий запит
+            prompt = (
+                "You are a research assistant. Your task is to:\n"
+                f"{task}\n\n"
+                "Provide a detailed response."
+            )
+            logger.info(f"Sending prompt to model: {prompt[:100]}...")
+            
+            result = self.model(prompt)
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in run method: {str(e)}")
+            return f"Error processing request: {str(e)}"
+
+    def format_research_report(self, content: Dict[str, Any]) -> str:
+        """
+        Форматування результатів у звіт.
         """
         try:
-            # Default sections for research report
             sections = [
                 "Executive Summary",
                 "Introduction",
@@ -47,75 +139,48 @@ class ResearchAgent(CodeAgent):
                 "References"
             ]
             
-            # Create report header
             report = [
                 "# Науковий звіт",
                 f"*Згенеровано: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*\n"
             ]
             
-            # Add each section
             for section in sections:
                 section_content = content.get(section, f"Розділ {section} не надано")
                 report.extend([
                     f"## {section}",
                     section_content,
-                    ""  # Empty line for readability
+                    ""
                 ])
             
             return "\n".join(report)
             
         except Exception as e:
             logger.error(f"Error formatting research report: {e}")
-            return str(content)  # Return raw content if formatting fails
-
-    def update_model(self, model_config):
-        """Update the model configuration"""
-        try:
-            from smolagents import HfApiModel
-            self.model = HfApiModel(
-                model_id=model_config['model_id'],
-                token=os.getenv('HF_API_TOKEN'),
-                temperature=model_config['parameters'].get('temperature', 0.7)
-            )
-            logger.info(f"Model updated to: {model_config['model_id']}")
-        except Exception as e:
-            logger.error(f"Error updating model: {e}")
-            raise
+            return str(content)
 
     def process_query(self, query: str, available_files: Optional[List[str]] = None) -> str:
         """
-        Process a research query and return formatted results.
-        
-        Args:
-            query (str): The research query to process
-            available_files (Optional[List[str]]): List of available file paths
-            
-        Returns:
-            str: Formatted research results
+        Обробка дослідницького запиту.
         """
         try:
-            logger.info(f"Processing research query: {query}")
+            logger.info(f"Обробка дослідницького запиту: {query}")
             
-            # Execute query
+            # Виконання запиту
             result = self.run(
                 task=query,
-                stream=False,  # We want complete results
-                reset=True     # Fresh start for each query
+                stream=False,
+                reset=True
             )
             
-            # Validate results
             if not result:
                 return "Не вдалося отримати результати. Будь ласка, спробуйте переформулювати запит."
             
-            # If result is already a string, return it
             if isinstance(result, str):
                 return result
             
-            # If result is a dict, format it as a report
             if isinstance(result, dict):
                 return self.format_research_report(result)
             
-            # Default case
             return str(result)
             
         except Exception as e:

app.py

@@ -1,15 +1,15 @@
-from smolagents import HfApiModel
 from tools.web_search import DuckDuckGoSearchTool
 from tools.final_answer import FinalAnswerTool
 from tools.healthcare_llm_visualizer import HealthcareLLMVisualizerTool
 from Gradio_UI import GradioUI
 from agent import ResearchAgent
+from model_init import ModelInitializer  # Новий імпорт
 import os
 from dotenv import load_dotenv
 import logging
-from config import ModelConfig
+from pathlib import Path
 
-# Configure logging
+# Налаштування логування
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
@@ -20,12 +20,12 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Load environment variables
+# Завантаження змінних середовища
 load_dotenv()
 
 def initialize_tools():
-    """Initialize all available tools with proper configuration"""
-    logger.info("Initializing tools...")
+    """Ініціалізація всіх доступних інструментів"""
+    logger.info("Ініціалізація інструментів...")
     try:
         tools = [
             DuckDuckGoSearchTool(
@@ -34,50 +34,51 @@ def initialize_tools():
             FinalAnswerTool(),
             HealthcareLLMVisualizerTool()
         ]
-        logger.info("Tools initialized successfully")
+        logger.info("Інструменти успішно ініціалізовано")
         return tools
     except Exception as e:
-        logger.error(f"Error initializing tools: {e}")
+        logger.error(f"Помилка ініціалізації інструментів: {e}")
         raise
 
-def initialize_model():
-    """Initialize the language model"""
-    logger.info("Initializing language model...")
+def initialize_model(model_key=None):
+    """Ініціалізація моделі"""
+    logger.info("Ініціалізація мовної моделі...")
     try:
-        model_config = ModelConfig()
-        default_model = model_config.get_model_config()
+        config_path = Path("models_config.json")
+        model_initializer = ModelInitializer(config_path)
+        model = model_initializer.initialize_model(model_key)
         
-        model = HfApiModel(
-            model_id=default_model['model_id'],
-            token=os.getenv('HF_API_TOKEN'),
-            temperature=default_model['parameters'].get('temperature', 0.7),
-            max_tokens=default_model['parameters'].get('max_tokens', 2048)
-        )
-        logger.info(f"Model initialized: {default_model['model_id']}")
-        return model
+        if model_key:
+            logger.info(f"Модель ініціалізовано: {model_key}")
+        else:
+            logger.info("Ініціалізовано модель за замовчуванням")
+        return model, model_initializer
     except Exception as e:
-        logger.error(f"Error initializing model: {e}")
+        logger.error(f"Помилка ініціалізації моделі: {e}")
         raise
 
 def main():
-    """Main application entry point"""
+    """Головна точка входу в програму"""
     try:
-        logger.info("Starting Research Agent application...")
+        logger.info("Запуск Research Agent...")
         
-        # Initialize components
+        # Ініціалізація компонентів
         tools = initialize_tools()
-        model = initialize_model()
+        model, model_initializer = initialize_model()
         
-        # Initialize research agent with increased max_steps
+        # Ініціалізація дослідницького агента
         agent = ResearchAgent(
             model=model,
             tools=tools,
-            max_steps=int(os.getenv('MAX_STEPS', 10)),  # Increased from 6 to 10
+            max_steps=int(os.getenv('MAX_STEPS', 10)),
             verbosity_level=int(os.getenv('VERBOSITY_LEVEL', 1))
         )
         
-        # Launch UI
-        logger.info("Launching Gradio interface...")
+        # Додавання model_initializer до агента для можливості зміни моделі
+        agent.model_initializer = model_initializer
+        
+        # Запуск інтерфейсу
+        logger.info("Запуск Gradio інтерфейсу...")
         ui = GradioUI(agent)
         ui.launch(
             debug=os.getenv('DEBUG_MODE', 'False').lower() == 'true',
@@ -87,7 +88,7 @@ def main():
         )
         
     except Exception as e:
-        logger.error(f"Application startup failed: {e}")
+        logger.error(f"Помилка запуску програми: {e}")
         raise
 
 if __name__ == "__main__":

config.py

@@ -1,112 +0,0 @@
-import json
-from pathlib import Path
-
-class ModelConfig:
-    def __init__(self, config_path='models_config.json'):  # Changed path
-        self.config_path = Path(config_path)
-        self.ensure_config_exists()
-        self.load_config()
-
-    def ensure_config_exists(self):
-        """Ensure config file exists"""
-        if not self.config_path.exists():
-            default_config = {
-                "models": {
-                    "deepseek-r1": {
-                        "model_id": "deepseek-ai/DeepSeek-R1",
-                        "description": "Найбільш рейтингова модель за кількістю лайків",
-                        "likes": 8659,
-                        "downloads": 3468420,
-                        "parameters": {
-                            "max_tokens": 2048,
-                            "temperature": 0.7,
-                            "top_p": 0.95,
-                            "frequency_penalty": 0.0,
-                            "presence_penalty": 0.0
-                        },
-                        "recommended_use": ["складні дослідницькі завдання", "аналітика", "генерація тексту"]
-                    },
-                    "llama-3-instruct": {
-                        "model_id": "meta-llama/Llama-3.1-8B-Instruct",
-                        "description": "Потужна інструктивна модель від Meta",
-                        "likes": 3612,
-                        "downloads": 6035070,
-                        "parameters": {
-                            "max_tokens": 4096,
-                            "temperature": 0.8,
-                            "top_p": 0.9,
-                            "frequency_penalty": 0.0,
-                            "presence_penalty": 0.0
-                        },
-                        "recommended_use": ["діалоги", "інструкції", "навчальні матеріали"]
-                    },
-                    "mistral-instruct": {
-                        "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
-                        "description": "Оптимізована інструктивна модель",
-                        "likes": 2650,
-                        "downloads": 3415777,
-                        "parameters": {
-                            "max_tokens": 2048,
-                            "temperature": 0.3,
-                            "top_p": 0.9,
-                            "frequency_penalty": 0.0,
-                            "presence_penalty": 0.0
-                        },
-                        "recommended_use": ["наукові дослідження", "структуровані відповіді"]
-                    },
-                    "gpt2": {
-                        "model_id": "openai-community/gpt2",
-                        "description": "Найбільш завантажувана модель",
-                        "likes": 2565,
-                        "downloads": 18299067,
-                        "parameters": {
-                            "max_tokens": 1024,
-                            "temperature": 0.9,
-                            "top_p": 0.9,
-                            "frequency_penalty": 0.0,
-                            "presence_penalty": 0.0
-                        },
-                        "recommended_use": ["базова генерація тексту", "прості завдання"]
-                    },
-                    "llama-3-1b": {
-                        "model_id": "meta-llama/Llama-3.2-1B",
-                        "description": "Легка версія Llama 3",
-                        "likes": 1559,
-                        "downloads": 8244484,
-                        "parameters": {
-                            "max_tokens": 2048,
-                            "temperature": 0.8,
-                            "top_p": 0.9,
-                            "frequency_penalty": 0.0,
-                            "presence_penalty": 0.0
-                        },
-                        "recommended_use": ["швидкі відповіді", "базова генерація"]
-                    }
-                },
-                "default_model": "mistral-instruct",
-                "model_selection_criteria": {
-                    "research": ["deepseek-r1", "mistral-instruct", "llama-3-instruct"],
-                    "general": ["gpt2", "llama-3-1b"],
-                    "instruction": ["mistral-instruct", "llama-3-instruct"]
-                }
-            }
-            self.config_path.write_text(json.dumps(default_config, indent=4, ensure_ascii=False))
-
-    def load_config(self):
-        """Load configuration from file"""
-        self.config = json.loads(self.config_path.read_text())
-
-    def get_model_config(self, model_key=None):
-        """Get configuration for specific model or default model"""
-        if model_key is None:
-            model_key = self.config['default_model']
-        return self.config['models'].get(model_key)
-
-    def get_available_models(self):
-        """Get list of available models"""
-        return [(key, model['description']) 
-                for key, model in self.config['models'].items()]
-
-    def get_default_model(self):
-        """Get default model key"""
-        return self.config['default_model']

model_init.py

@@ -0,0 +1,295 @@
+from typing import Optional, Dict, Any
+import os
+import google.generativeai as genai
+from huggingface_hub import HfApi
+import logging
+from smolagents import HfApiModel
+
+logger = logging.getLogger(__name__)
+
+class ModelWrapper:
+    """Спрощена обгортка для моделей"""
+    
+    def __init__(self, model, model_type):
+        self.model = model
+        self.model_type = model_type
+
+    def __call__(self, prompt, **kwargs):
+        try:
+            if self.model_type == 'gemini':
+                # Якщо prompt - це словник з роллю і контентом
+                if isinstance(prompt, dict) and 'content' in prompt:
+                    text = prompt['content']
+                # Якщо prompt - це список повідомлень
+                elif isinstance(prompt, list):
+                    # Беремо останнє повідомлення
+                    last_message = prompt[-1]
+                    text = last_message.get('content', '') if isinstance(last_message, dict) else str(last_message)
+                else:
+                    text = str(prompt)
+
+                logger.info(f"Prompt для Gemini: {text[:100]}...")
+                response = self.model.generate_content(text)
+                return response.text
+            else:
+                kwargs.pop('stop_sequences', None)  # Видаляємо stop_sequences для HF моделей
+                return self.model(prompt, **kwargs)
+                
+        except Exception as e:
+            logger.error(f"Помилка ModelWrapper: {str(e)}")
+            logger.error(f"Тип prompt: {type(prompt)}")
+            logger.error(f"Prompt: {str(prompt)[:200]}")
+            raise
+    """Обгортка для уніфікації інтерфейсу різних моделей"""
+    
+    def __init__(self, model, model_type):
+        self.model = model
+        self.model_type = model_type
+
+    def _extract_text_from_input(self, input_data):
+        """Витягує текст з різних форматів вхідних даних"""
+        try:
+            if isinstance(input_data, str):
+                return input_data
+                
+            elif isinstance(input_data, list):
+                # Обробка списку повідомлень
+                messages = []
+                for msg in input_data:
+                    if isinstance(msg, dict):
+                        # Витягуємо контент з повідомлення
+                        content = msg.get('content', '')
+                        if isinstance(content, list):
+                            # Якщо контент - список, обробляємо кожен елемент
+                            for item in content:
+                                if isinstance(item, dict) and 'text' in item:
+                                    messages.append(item['text'])
+                                else:
+                                    messages.append(str(item))
+                        else:
+                            messages.append(str(content))
+                    else:
+                        messages.append(str(msg))
+                return ' '.join(messages)
+                
+            elif isinstance(input_data, dict):
+                # Обробка одиночного повідомлення
+                content = input_data.get('content', '')
+                if isinstance(content, list):
+                    return ' '.join(item.get('text', str(item)) for item in content if isinstance(item, dict))
+                return str(content)
+                
+            return str(input_data)
+            
+        except Exception as e:
+            logger.error(f"Помилка при обробці вхідних даних: {e}")
+            logger.error(f"Тип даних: {type(input_data)}")
+            logger.error(f"Дані: {str(input_data)[:200]}")
+            return str(input_data)
+
+    def __call__(self, prompt: str, **kwargs) -> str:
+        """
+        Виклик моделі з підтримкою додаткових параметрів.
+        
+        Args:
+            prompt: Текст запиту
+            **kwargs: Додаткові параметри (ігноруються для Gemini)
+        """
+        try:
+            if self.model_type == 'gemini':
+                # Для Gemini ігноруємо додаткові параметри і просто передаємо текст
+                text = self._extract_text_from_input(prompt)
+                logger.info(f"Gemini отримав запит: {text[:200]}...")  # Логуємо перші 200 символів
+                
+                response = self.model.generate_content(text)
+                
+                if response and hasattr(response, 'text'):
+                    logger.info("Gemini успішно згенерував відповідь")
+                    return response.text
+                else:
+                    error_msg = "Gemini повернув порожню або неправильну відповідь"
+                    logger.error(error_msg)
+                    raise ValueError(error_msg)
+            else:  # huggingface model
+                # Видаляємо stop_sequences, якщо він є
+                kwargs.pop('stop_sequences', None)
+                return self.model(prompt, **kwargs)
+        except Exception as e:
+            logger.error(f"Помилка при виклику моделі {self.model_type}: {e}")
+            logger.error(f"Тип вхідних даних: {type(prompt)}")
+            logger.error(f"Вміст вхідних даних: {str(prompt)[:200]}")
+            raise
+    """Обгортка для уніфікації інтерфейсу різних моделей"""
+    
+    def __init__(self, model, model_type):
+        self.model = model
+        self.model_type = model_type
+
+    def _extract_text_from_input(self, input_data):
+        """Витягує текст з різних форматів вхідних даних"""
+        if isinstance(input_data, str):
+            return input_data
+        elif isinstance(input_data, dict):
+            return input_data.get('content', str(input_data))
+        elif isinstance(input_data, list):
+            return ' '.join(self._extract_text_from_input(item) for item in input_data)
+        return str(input_data)
+
+    def __call__(self, prompt: str, **kwargs) -> str:
+        """
+        Виклик моделі з підтримкою додаткових параметрів.
+        
+        Args:
+            prompt: Текст запиту
+            **kwargs: Додаткові параметри (ігноруються для Gemini)
+        """
+        try:
+            if self.model_type == 'gemini':
+                # Для Gemini ігноруємо додаткові параметри і просто передаємо текст
+                text = self._extract_text_from_input(prompt)
+                logger.info(f"Gemini отримав запит: {text[:200]}...")  # Логуємо перші 200 символів
+                
+                response = self.model.generate_content(text)
+                
+                if response and hasattr(response, 'text'):
+                    logger.info("Gemini успішно згенерував відповідь")
+                    return response.text
+                else:
+                    error_msg = "Gemini повернув порожню або неправильну відповідь"
+                    logger.error(error_msg)
+                    raise ValueError(error_msg)
+            else:  # huggingface model
+                # Видаляємо stop_sequences, якщо він є
+                kwargs.pop('stop_sequences', None)
+                return self.model(prompt, **kwargs)
+        except Exception as e:
+            logger.error(f"Помилка при виклику моделі {self.model_type}: {e}")
+            logger.error(f"Тип вхідних даних: {type(prompt)}")
+            logger.error(f"Вміст вхідних даних: {str(prompt)[:200]}")  # Логуємо перші 200 символів
+            raise
+
+class ModelInitializer:
+    def __init__(self, config_path: str = 'models_config.json'):
+        self.config = self._load_config(config_path)
+        self._setup_api_keys()
+        
+    def _setup_api_keys(self):
+        """Налаштування API ключів"""
+        self.hf_api_token = os.getenv('HF_API_TOKEN')
+        self.gemini_api_key = os.getenv('GEMINI_API_KEY')
+        if self.gemini_api_key:
+            genai.configure(api_key=self.gemini_api_key)
+            logger.info("API ключ Gemini успішно налаштовано")
+        else:
+            logger.warning("API ключ Gemini не знайдено")
+            
+    def _load_config(self, config_path: str) -> Dict[str, Any]:
+        """Завантаження конфігурації моделей"""
+        import json
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            logger.info(f"Конфігурацію успішно завантажено з {config_path}")
+            return config
+        except Exception as e:
+            logger.error(f"Помилка завантаження конфігурації: {e}")
+            raise
+            
+    def initialize_model(self, model_key: Optional[str] = None) -> Any:
+        """Ініціалізація вибраної моделі"""
+        try:
+            if model_key is None:
+                model_key = self.config['default_model']
+                logger.info(f"Використовуємо модель за замовчуванням: {model_key}")
+                
+            model_config = self.config['models'].get(model_key)
+            if not model_config:
+                error_msg = f"Модель {model_key} не знайдена в конфігурації"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+                
+            if model_key == 'gemini-flash':
+                model = self._initialize_gemini(model_config)
+                logger.info("Ініціалізовано Gemini модель")
+                return ModelWrapper(model, 'gemini')
+            else:
+                model = self._initialize_huggingface(model_config)
+                logger.info("Ініціалізовано HuggingFace модель")
+                return ModelWrapper(model, 'huggingface')
+        except Exception as e:
+            error_msg = f"Помилка ініціалізації моделі: {e}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+    def _initialize_gemini(self, config: Dict[str, Any]) -> Any:
+        """Ініціалізація Gemini моделі"""
+        if not self.gemini_api_key:
+            raise ValueError("GEMINI_API_KEY не знайдено в змінних середовища")
+            
+        try:
+            # Налаштування безпеки (вимикаємо всі обмеження для наукових досліджень)
+            safety_settings = [
+                {
+                    "category": "HARM_CATEGORY_HARASSMENT",
+                    "threshold": "BLOCK_NONE"
+                },
+                {
+                    "category": "HARM_CATEGORY_HATE_SPEECH",
+                    "threshold": "BLOCK_NONE"
+                },
+                {
+                    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                    "threshold": "BLOCK_NONE"
+                },
+                {
+                    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                    "threshold": "BLOCK_NONE"
+                }
+            ]
+            
+            # Створюємо модель з мінімальними обмеженнями
+            model = genai.GenerativeModel(
+                model_name='gemini-pro',
+                safety_settings=safety_settings
+            )
+            
+            # Тестуємо модель
+            try:
+                logger.info("Тестування з'єднання з Gemini...")
+                test_response = model.generate_content("Test connection")
+                if test_response and hasattr(test_response, 'text'):
+                    logger.info("Gemini модель успішно ініціалізовано та протестовано")
+                    return model
+                else:
+                    raise ValueError("Тестова генерація не повернула текст")
+            except Exception as e:
+                raise ValueError(f"Помилка тестування Gemini: {str(e)}")
+                
+        except Exception as e:
+            error_msg = f"Помилка ініціалізації Gemini: {str(e)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+    def _initialize_huggingface(self, config: Dict[str, Any]) -> Any:
+        """Ініціалізація Hugging Face моделі"""
+        if not self.hf_api_token:
+            raise ValueError("HF_API_TOKEN не знайдено в змінних середовища")
+            
+        try:
+            model = HfApiModel(
+                model_id=config['model_id'],
+                token=self.hf_api_token,
+                temperature=config['parameters']['temperature'],
+                max_tokens=config['parameters']['max_tokens']
+            )
+            
+            return model
+        except Exception as e:
+            error_msg = f"Помилка ініціалізації HuggingFace: {str(e)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+    def get_available_models(self) -> list:
+        """Отримання списку доступних моделей"""
+        return [(key, model['description']) 
+                for key, model in self.config['models'].items()]

models_config.json

@@ -1,80 +1,30 @@
 {
     "models": {
-        "deepseek-r1": {
-            "model_id": "deepseek-ai/DeepSeek-R1",
-            "description": "Найбільш рейтингова модель за кількістю лайків",
-            "likes": 8659,
-            "downloads": 3468420,
+        "gemini-flash": {
+            "model_id": "gemini-pro",
+            "description": "Швидка та потужна модель від Google",
             "parameters": {
-                "max_tokens": 2048,
-                "temperature": 0.7,
+                "max_tokens": 8192,
+                "temperature": 1.0,
                 "top_p": 0.95,
-                "frequency_penalty": 0.0,
-                "presence_penalty": 0.0
-            },
-            "recommended_use": ["складні дослідницькі завдання", "аналітика", "генерація тексту"]
-        },
-        "llama-3-instruct": {
-            "model_id": "meta-llama/Llama-3.1-8B-Instruct",
-            "description": "Потужна інструктивна модель від Meta",
-            "likes": 3612,
-            "downloads": 6035070,
-            "parameters": {
-                "max_tokens": 4096,
-                "temperature": 0.8,
-                "top_p": 0.9,
-                "frequency_penalty": 0.0,
-                "presence_penalty": 0.0
-            },
-            "recommended_use": ["діалоги", "інструкції", "навчальні матеріали"]
+                "top_k": 40
+            }
         },
         "mistral-instruct": {
             "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
             "description": "Оптимізована інструктивна модель",
-            "likes": 2650,
-            "downloads": 3415777,
             "parameters": {
                 "max_tokens": 2048,
                 "temperature": 0.3,
                 "top_p": 0.9,
                 "frequency_penalty": 0.0,
                 "presence_penalty": 0.0
-            },
-            "recommended_use": ["наукові дослідження", "структуровані відповіді"]
-        },
-        "gpt2": {
-            "model_id": "openai-community/gpt2",
-            "description": "Найбільш завантажувана модель",
-            "likes": 2565,
-            "downloads": 18299067,
-            "parameters": {
-                "max_tokens": 1024,
-                "temperature": 0.9,
-                "top_p": 0.9,
-                "frequency_penalty": 0.0,
-                "presence_penalty": 0.0
-            },
-            "recommended_use": ["базова генерація тексту", "прості завдання"]
-        },
-        "llama-3-1b": {
-            "model_id": "meta-llama/Llama-3.2-1B",
-            "description": "Легка версія Llama 3",
-            "likes": 1559,
-            "downloads": 8244484,
-            "parameters": {
-                "max_tokens": 2048,
-                "temperature": 0.8,
-                "top_p": 0.9,
-                "frequency_penalty": 0.0,
-                "presence_penalty": 0.0
-            },
-            "recommended_use": ["швидкі відповіді", "базова генерація"]
+            }
         }
     },
-    "default_model": "mistral-instruct",
+    "default_model": "gemini-flash",
     "model_selection_criteria": {
-        "research": ["deepseek-r1", "mistral-instruct", "llama-3-instruct"],
-        "general": ["gpt2", "llama-3-1b"],
-        "instruction": ["mistral-instruct", "llama-3-instruct"]
+        "research": ["gemini-flash", "mistral-instruct"],
+        "instruction": ["gemini-flash", "mistral-instruct"]
     }
 }

requirements.txt

@@ -6,4 +6,5 @@ duckduckgo-search>=3.0.0
 markdownify>=0.11.0
 requests>=2.28.0
 pandas>=1.3.0
-numpy>=1.21.0
+numpy>=1.21.0
+google-generativeai>=0.3.0

test_gemini.py

@@ -0,0 +1,47 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+import logging
+
+# Налаштування логування
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def test_gemini():
+    try:
+        # Завантаження API ключа
+        load_dotenv()
+        api_key = os.getenv('GEMINI_API_KEY')
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY не знайдено")
+            
+        # Конфігурація Gemini
+        genai.configure(api_key=api_key)
+        
+        # Створення моделі
+        model = genai.GenerativeModel('gemini-pro')
+        
+        # Тестовий запит
+        prompt = "What is 2+2? Answer in one word."
+        logger.info(f"Sending test prompt: {prompt}")
+        
+        # Генерація відповіді
+        response = model.generate_content(prompt)
+        
+        if response and hasattr(response, 'text'):
+            logger.info(f"Response received: {response.text}")
+            return True
+        else:
+            logger.error("No valid response received")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Error testing Gemini: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    print("Testing Gemini connection...")
+    if test_gemini():
+        print("Test successful!")
+    else:
+        print("Test failed!")