не работает функция памяти, поиска в интернете, исправления собственного кода, исправь

Мой код:


import os
import sys
import json
import logging
from typing import Dict, Any, List
import datetime
from datetime import datetime

# Базовые библиотеки для голосового управления
import speech_recognition as sr
import requests
from bs4 import BeautifulSoup
import urllib.parse

# Библиотеки для машинного обучения и векторизации
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Библиотека Ollama
import ollama

class AdvancedVoiceAssistant:
    def __init__(self):
        # Настройка логирования
        logging.basicConfig(level=logging.INFO,
                            format='%(asctime)s - %(levelname)s - %(message)s',
                            filename='assistant_log.txt')
        self.logger = logging.getLogger(__name__)

        # Инициализация базовых моделей
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()

        # Параметры обучения
        self.memory_file = 'assistant_memory.json'
        self.knowledge_base = self._load_knowledge_base()

        # Настройки векторизации
        self.vectorizer = TfidfVectorizer(stop_words='russian')

    def _load_knowledge_base(self):
        """Загрузка базы знаний"""
        try:
            with open(self.memory_file, 'r', encoding='utf-8') as f:
                knowledge_base = json.load(f)
                return knowledge_base
        except FileNotFoundError:
            return {
                'search_history': [],
                'learned_information': {},
                'performance_metrics': {
                    'accuracy': [],
                    'response_time': [],
                    'query_complexity': []
                }
            }

    def listen(self):
        """
        Функция для прослушивания и распознавания речи с использованием микрофона.
        """
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            print("Listening...")
            audio = self.recognizer.listen(source)
        try:
            query = self.recognizer.recognize_google(audio, language="ru-RU")
            print(f"You said: {query}")
            return query
        except sr.UnknownValueError:
            print("Извините, я не смогла понять вашу речь.")
            return ""
        except sr.RequestError:
            print("Ошибка запроса к сервису распознавания.")
            return ""

    def respond(self, response_text):
        """
        Функция для синтеза и воспроизведения речи.
        """
        print(response_text)

    def run(self):
        """Основной цикл работы ассистента"""
        print("Запуск продвинутого голосового ассистента...")
        while True:
            try:
                # Голосовой ввод
                query = self.listen()
                if not query:
                    continue
                if self._requires_internet_search(query):
                    # Выполнение поиска
                    search_results = self.internet_search(query)
                    # Анализ результатов
                    performance = self._gpu_accelerated_analysis(search_results)
                    # Самоулучшение
                    self.improve_self(performance)
                    # Формирование ответа на основе поиска
                    response = self._formulate_response_with_search(query, search_results)
                else:
                    # Генерация ответа с использованием Ollama
                    response = self.generate_response(query)
                self.respond(response)
            except KeyboardInterrupt:
                print("Завершение работы...")
                break
            except Exception as e:
                print(f"Непредвиденная ошибка: {e}")

    def _requires_internet_search(self, query: str) -> bool:
        """
        Определяет, требует ли запрос выполнения веб-поиска.
        Args:
            query (str): Входной запрос пользователя.
        Returns:
            bool: True, если запрос требует веб-поиска, иначе False.
        """
        keywords = ['сколько времени', 'погода', 'новости', 'цена', 'курс валют', 'расписание']
        query_lower = query.lower()
        return any(keyword in query_lower for keyword in keywords)

    def generate_response(self, query: str) -> str:
        """
        Генерация ответа с использованием Ollama.
        Args:
            query (str): Входной запрос
        Returns:
            str: Сгенерированный ответ
        """
        try:
            response = ollama.chat(
                model='gemma2',
                messages=[{'role': 'user', 'content': query}]
            )
            return response['message']['content']
        except ollama.ResponseError as e:
            self.logger.error(f"Ошибка при обращении к модели Ollama: {e.error}")
            if e.status_code == 404:
                self.logger.info(f"Модель {e.model} не найдена. Пытаюсь выполнить pull.")
                try:
                    ollama.pull(e.model)
                    self.logger.info(f"Модель {e.model} успешно загружена.")
                    # Повторный запрос после загрузки модели
                    response = ollama.chat(
                        model=e.model,
                        messages=[{'role': 'user', 'content': query}]
                    )
                    return response['message']['content']
                except Exception as pull_error:
                    self.logger.error(f"Не удалось загрузить модель после ошибки 404: {pull_error}")
                    return "Извините, не удалось загрузить необходимую модель."
            return "Извините, произошла ошибка при генерации ответа."

    def _gpu_accelerated_analysis(self, search_results):
        """
        Анализ результатов поиска с использованием векторизации.
        Args:
            search_results (List[Dict]): Результаты поиска
        Returns:
            Dict: Метрики производительности
        """
        try:
            # Извлечение текста
            texts = [result['snippet'] for result in search_results]
            # Векторизация
            vectors = self.vectorizer.fit_transform(texts).toarray()
            # Вычисление сходства
            similarity_matrix = cosine_similarity(vectors)
            # Метрики производительности
            performance_metrics = {
                'unique_sources': len(set(result['link'] for result in search_results)),
                'avg_similarity': float(np.mean(similarity_matrix)),
                'max_similarity': float(np.max(similarity_matrix))
            }
            return performance_metrics
        except Exception as e:
            print(f"Ошибка анализа результатов поиска: {e}")
            return {}

    def internet_search(self, query):
        """
        Функция для выполнения интернет-поиска.
        Реализуйте её в соответствии с вашими потребностями.
        """
        # Пример реализации поиска с использованием DuckDuckGo через API
        search_url = "https://api.duckduckgo.com/"
        params = {
            'q': query,
            'format': 'json',
            'no_html': 1,
            'skip_disambig': 1
        }
        try:
            response = requests.get(search_url, params=params)
            response.raise_for_status()
            data = response.json()
            # Извлечение краткого ответа
            answer = data.get('AbstractText', '')
            if not answer:
                # Извлечение из RelatedTopics
                related = data.get('RelatedTopics', [])
                if related:
                    answer = related[0].get('Text', '')
            return {'answer': answer}
        except requests.RequestException as e:
            print(f"Ошибка при выполнении поиска: {e}")
            return {'answer': "Извините, я не смог выполнить поиск в интернете."}

    def _formulate_response_with_search(self, query: str, search_results: Dict[str, str]) -> str:
        """
        Формирует ответ на основе результатов веб-поиска.
        Args:
            query (str): Входной запрос пользователя.
            search_results (Dict[str, str]): Результаты веб-поиска.
        Returns:
            str: Сформированный ответ.
        """
        if 'answer' in search_results and search_results['answer']:
            return search_results['answer']
        else:
            return "Извините, я не смог найти ответ на ваш вопрос."

    def improve_self(self, performance_metrics):
        """
        Пример функции для самоулучшения на основе метрик.
        Реализуйте её в соответствии с вашими потребностями.
        """
        # Обновление базы знаний
        self.knowledge_base['performance_metrics']['accuracy'].append(performance_metrics.get('avg_similarity', 0))
        self.knowledge_base['performance_metrics']['response_time'].append(0)  # Замените на реальное значение
        self.knowledge_base['performance_metrics']['query_complexity'].append(1)  # Замените на реальное значение

        # Сохранение обновленной базы знаний
        try:
            with open(self.memory_file, 'w', encoding='utf-8') as f:
                json.dump(self.knowledge_base, f, ensure_ascii=False, indent=4)
        except Exception as e:
            self.logger.error(f"Ошибка при сохранении базы знаний: {e}")

    def internet_search_backup(self, query):
        """
        Альтернативная реализация интернет-поиска, если основной метод не работает.
        """
        search_url = "https://www.google.com/search"
        params = {'q': query}
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
        }
        try:
            response = requests.get(search_url, params=params, headers=headers)
            response.raise_for_status()
        except requests.RequestException as e:
            print(f"Ошибка при выполнении поиска: {e}")
            return []

        soup = BeautifulSoup(response.text, 'html.parser')
        results = []
        for g in soup.find_all('div', class_='g'):
            title = g.find('h3')
            link = g.find('a', href=True)
            snippet = g.find('span', class_='aCOpRe')
            if title and link and snippet:
                results.append({
                    'title': title.text,
                    'link': link['href'],
                    'snippet': snippet.text
                })
        return results

    def _formulate_response_with_backup_search(self, query: str, search_results: List[Dict[str, str]]) -> str:
        """
        Формирует ответ на основе результатов веб-поиска через бэкап метод.
        Args:
            query (str): Входной запрос пользователя.
            search_results (List[Dict[str, str]]): Результаты веб-поиска.
        Returns:
            str: Сформированный ответ.
        """
        if search_results:
            # Возьмём первый результат для ответа
            first_result = search_results[0]
            return f"{first_result['snippet']} Подробнее: {first_result['link']}"
        else:
            return "Извините, я не смог найти ответ на ваш вопрос."

def main():
    assistant = AdvancedVoiceAssistant()
    assistant.run()

if __name__ == "__main__":
    main()