Upload 16 files

agent.py

@@ -0,0 +1,84 @@
+# agent.py
+import argparse
+from langchain_openai.chat_models import ChatOpenAI
+from langchain.agents import initialize_agent
+from langchain.tools import Tool
+from config import config
+
+from tools.gaia_tool import GaiaQATool
+from tools.wiki_tool import WikiSearchTool
+from tools.youtube_species_tool import YouTubeSpeciesTool
+from tools.youtube_transcription_tool import YouTubeTranscriptionTool
+from tools.excel_tool import ExcelTool
+from tools.codegen_tool import CodeGenTool
+from tools.web_search_tool import WebSearchTool
+from tools.string_tool import StringTool
+from tools.chess_tool import ChessTool
+from tools.group_tool import GroupTool
+from tools.grocery_tool import GroceryTool
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Многофункциональный QA агент")
+    parser.add_argument(
+        "--input", required=True,
+        help="Вопрос, URL или команда для инструмента"
+    )
+    args = parser.parse_args()
+    user_input = args.input
+
+    # Инициализируем LLM
+    llm = ChatOpenAI(
+        model_name=config.OPENAI_MODEL,
+        openai_api_key=config.OPENAI_API_KEY,
+        temperature=0.0
+    )
+
+    # Создаём и сохраняем инстансы инструментов
+    gaia = GaiaQATool()
+    wiki = WikiSearchTool()
+    species = YouTubeSpeciesTool()
+    transcript = YouTubeTranscriptionTool()
+    excel = ExcelTool()
+    codegen = CodeGenTool()
+    web = WebSearchTool()
+    string_tool = StringTool()
+    chess = ChessTool()
+    group = GroupTool()
+    grocery = GroceryTool()
+
+    # Собираем список Tool(...) из инстансов
+    tools = [
+        Tool(name=gaia.name, func=gaia._run, description=gaia.description),
+        Tool(name=wiki.name, func=wiki._run, description=wiki.description),
+        Tool(name=species.name, func=species._run, description=species.description),
+        Tool(name=transcript.name, func=transcript._run, description=transcript.description),
+        Tool(name=excel.name, func=excel._run, description=excel.description),
+        Tool(name=codegen.name, func=codegen._run, description=codegen.description),
+        Tool(name=web.name, func=web._run, description=web.description),
+        Tool(name=string_tool.name, func=string_tool._run, description=string_tool.description),
+        Tool(name=chess.name, func=chess._run, description=chess.description),
+        Tool(name=group.name, func=group._run, description=group.description),
+        Tool(name=grocery.name, func=grocery._run, description=grocery.description),
+    ]
+
+    # Инициализируем агента в режиме zero-shot-react-description
+    agent = initialize_agent(
+        tools=tools,
+        llm=llm,
+        agent="zero-shot-react-description",
+        verbose=True,
+        max_iterations=30,  # <-- увеличили число итераций
+        early_stopping_method="force",  # или "generate"
+        handle_parsing_errors=True  # при ошибках парсинга пробует ещё раз
+    )
+
+    # Запускаем и получаем ответ
+    answer = agent.invoke(user_input)
+    print("\nОтвет:\n", answer)
+
+if __name__ == "__main__":
+    main()
+
+
+
+

config.py

@@ -0,0 +1,9 @@
+# config.py
+from easydict import EasyDict
+
+# Пропишите ваш API-ключ OpenAI и используемую модель прямо здесь
+config = EasyDict({
+    "OPENAI_API_KEY": "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",
+    "OPENAI_MODEL": "gpt-4.1",
+    "WHISPER_MODEL": "base",
+})

requirements.txt

@@ -0,0 +1,15 @@
+langchain-openai~=0.3.14
+langchain~=0.3.24
+langchain-community~=0.3.22
+pydantic~=2.11.3
+chess~=1.11.2
+pandas~=2.2.3
+opencv-python~=4.11.0.86
+torch~=2.7.0
+torchvision~=0.22.0
+pytube~=15.0.0
+requests~=2.32.3
+beautifulsoup4~=4.13.4
+yt-dlp~=2025.3.31
+openai-whisper~=20240930
+easydict~=1.13

tools/chess_tool.py

@@ -0,0 +1,22 @@
+# tools/chess_tool.py
+from langchain.tools import BaseTool
+import chess
+import chess.engine
+
+class ChessTool(BaseTool):
+    """
+    Инструмент для анализа шахматных позиций.
+    Принимает FEN-строку и возвращает лучший ход по UCI с помощью Stockfish.
+    """
+    name: str = "chess_tool"
+    description: str = "Возвращает лучший ход в шахматной позиции (FEN) через Stockfish."
+
+    def _run(self, fen: str) -> str:
+        board = chess.Board(fen)
+        # Запускаем движок Stockfish (должен быть в PATH)
+        with chess.engine.SimpleEngine.popen_uci("stockfish") as engine:
+            result = engine.play(board, chess.engine.Limit(depth=20))
+        return result.move.uci()
+
+    async def _arun(self, fen: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/codegen_tool.py

@@ -0,0 +1,24 @@
+from langchain.tools import BaseTool
+from langchain_openai.llms import OpenAI
+from config import config
+
+class CodeGenTool(BaseTool):
+    """
+    Инструмент для генерации кода по текстовому описанию.
+    """
+    name: str = "code_gen"
+    description: str = "Генерирует Python-код по спецификации."
+
+    def _run(self, spec: str) -> str:
+        llm = OpenAI(
+            model_name=config.OPENAI_MODEL,
+            openai_api_key=config.OPENAI_API_KEY,
+            temperature=0.2
+        )
+        prompt = f"Write Python code to: {spec}"
+        return llm.invoke(prompt)
+
+    async def _arun(self, spec: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+

tools/excel_tool.py

@@ -0,0 +1,27 @@
+from langchain.tools import BaseTool
+import pandas as pd
+
+class ExcelTool(BaseTool):
+    """
+    Инструмент для выполнения простых запросов к Excel-файлам.
+    Формат команды: 'path.xlsx,sheet=Sheet1,query=mean(columnA)'
+    """
+    name: str = "excel_query"
+    description: str = (
+        "Загружает .xlsx, выполняет заданный запрос Pandas и возвращает результат."
+    )
+
+    def _run(self, command: str) -> str:
+        path, rest = command.split(',', 1)
+        opts = dict(item.split('=') for item in rest.split(','))
+        df = pd.read_excel(path.strip(), sheet_name=opts.get('sheet','Sheet1').strip())
+        query = opts.get('query','').strip()
+        if query.startswith('mean(') and query.endswith(')'):
+            col = query[5:-1]
+            return str(df[col].mean())
+        return df.to_string(index=False)
+
+    async def _arun(self, command: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+

tools/gaia_tool.py

@@ -0,0 +1,22 @@
+from langchain_openai.llms import OpenAI
+from langchain.tools import BaseTool
+from config import config
+
+class GaiaQATool(BaseTool):
+    """
+    Инструмент для ответов на вопросы GAIA Level 1.
+    """
+    name: str = "gaia_level1_qa"
+    description: str = "Отвечает на GAIA Level1 вопросы."
+
+    def _run(self, question: str) -> str:
+        llm = OpenAI(
+            model_name=config.OPENAI_MODEL,
+            openai_api_key=config.OPENAI_API_KEY,
+            temperature=0
+        )
+        prompt = f"Answer GAIA Level 1 question: {question}"
+        return llm.invoke(prompt)
+
+    async def _arun(self, question: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/grocery_tool.py

@@ -0,0 +1,40 @@
+# tools/grocery_tool.py
+from langchain.tools import BaseTool
+from typing import List
+
+def is_vegetable(item: str) -> bool:
+    vegs = {
+        "broccoli",
+        "bell pepper",
+        "celery",
+        "corn",
+        "green beans",
+        "lettuce",
+        "peanuts",
+        "rice",
+        "zucchini"
+    }
+    return item.lower() in vegs
+
+class GroceryTool(BaseTool):
+    """
+    Инструмент для выделения овощей или фруктов из списка.
+    Использовать префиксы 'vegetables:' или 'fruits:' в команде.
+    """
+    name: str = "grocery_tool"
+    description: str = "Выделяет из списка овощи по префиксу 'vegetables:'."
+
+    def _run(self, command: str) -> str:
+        cmd = command.strip()
+        if cmd.lower().startswith('vegetables:'):
+            items = [x.strip() for x in cmd[len('vegetables:'):].split(',')]
+            veg_list: List[str] = [i for i in items if is_vegetable(i)]
+            return ','.join(sorted(veg_list))
+        elif cmd.lower().startswith('fruits:'):
+            # При необходимости можно добавить проверку фруктов
+            return "Фруктовый режим пока не реализован."
+        else:
+            return f"Неподдерживаемая категория: {command}"
+
+    async def _arun(self, command: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/group_tool.py

@@ -0,0 +1,32 @@
+# tools/group_tool.py
+from langchain.tools import BaseTool
+
+class GroupTool(BaseTool):
+    """
+    Инструмент для поиска контрпримеров некоммутативности в заданной таблице операции.
+    """
+    name: str = "group_tool"
+    description: str = "Находит элементы, участвующие в контр-примерах некоммутативности."
+
+    def _run(self, table: str) -> str:
+        # Парсим строки таблицы вида Markdown
+        lines = [l for l in table.splitlines() if '|' in l]
+        # Заголовок: имена элементов
+        elems = [x.strip() for x in lines[0].split('|')[1:-1]]
+        # Матрица значений
+        mat = []
+        for row in lines[1:]:
+            vals = [x.strip() for x in row.split('|')[1:-1]]
+            mat.append(vals)
+        # Собираем пары (a,b), где a*b != b*a
+        bad = set()
+        for i, a in enumerate(elems):
+            for j, b in enumerate(elems):
+                if mat[i][j] != mat[j][i]:
+                    bad.add(a)
+                    bad.add(b)
+        # Возвращаем элементы в алфавитном порядке
+        return ','.join(sorted(bad))
+
+    async def _arun(self, table: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/string_tool.py

@@ -0,0 +1,18 @@
+# tools/string_tool.py
+from langchain.tools import BaseTool
+
+class StringTool(BaseTool):
+    """
+    Операции над строками: реверс текста по префиксу 'reverse:'.
+    """
+    name: str = "string_tool"
+    description: str = "Реверсирует часть строки после 'reverse:'."
+
+    def _run(self, text: str) -> str:
+        if text.lower().startswith('reverse:'):
+            s = text[len('reverse:'):].strip()
+            return s[::-1]
+        return f"Неизвестная операция: {text}"
+
+    async def _arun(self, text: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/web_search_tool.py

@@ -0,0 +1,28 @@
+from langchain.tools import BaseTool
+import requests
+from bs4 import BeautifulSoup
+
+class WebSearchTool(BaseTool):
+    """
+    Инструмент для простого веб-поиска (Google) — возвращает топ-5 результатов.
+    """
+    name: str = "web_search"
+    description: str = "Выполняет поиск Google и возвращает заголовки и ссылки."
+
+    def _run(self, query: str) -> str:
+        resp = requests.get(
+            'https://www.google.com/search',
+            params={'q': query},
+            headers={'User-Agent': 'Mozilla/5.0'}
+        )
+        soup = BeautifulSoup(resp.text, 'html.parser')
+        results = []
+        for g in soup.select('div.yuRUbf')[:5]:
+            a = g.a
+            results.append(f"{a.text} - {a['href']}")
+        return "\n".join(results)
+
+    async def _arun(self, query: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+

tools/wiki_tool.py

@@ -0,0 +1,25 @@
+from langchain.tools import BaseTool
+from langchain_community.utilities import WikipediaAPIWrapper
+from pydantic import PrivateAttr
+
+class WikiSearchTool(BaseTool):
+    """
+    Инструмент для поиска в English Wikipedia.
+    """
+    name: str = "wiki_search"
+    description: str = "Краткая выжимка статьи из English Wikipedia по запросу."
+    _wrapper: WikipediaAPIWrapper = PrivateAttr()
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._wrapper = WikipediaAPIWrapper(lang="en")
+
+    def _run(self, query: str) -> str:
+        return self._wrapper.run(query)
+
+    async def _arun(self, query: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+
+
+

tools/youtube_species_tool.py

@@ -0,0 +1,71 @@
+from langchain.tools import BaseTool
+import cv2
+import tempfile
+import os
+import torch
+import torchvision.transforms as T
+from torchvision.models.detection import fasterrcnn_resnet50_fpn
+import re
+import yt_dlp
+
+class YouTubeSpeciesTool(BaseTool):
+    """
+    Инструмент для анализа видео YouTube: находит максимальное число птиц в кадре.
+    Скачивает видео через yt-dlp и детектирует птиц Faster R-CNN.
+    """
+    name: str = "youtube_species"
+    description: str = (
+        "Скачивает видео по URL, детектирует птиц с помощью Faster R-CNN "
+        "и возвращает максимальное число птиц в кадре."
+    )
+
+    def _run(self, text: str) -> str:
+        # 1) Извлекаем URL из произвольного текста
+        m = re.search(r"(https?://[^\s,]+)", text)
+        if not m:
+            return "Ошибка: не найден корректный URL."
+        url = m.group(1)
+
+        # 2) Скачиваем видео через yt-dlp
+        temp_dir = tempfile.mkdtemp()
+        ydl_opts = {
+            "outtmpl": os.path.join(temp_dir, "%(id)s.%(ext)s"),
+            "format": "mp4",
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+        video_path = os.path.join(temp_dir, f"{info['id']}.mp4")
+
+        # 3) Готовим модель
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = fasterrcnn_resnet50_fpn(pretrained=True).to(device)
+        model.eval()
+        transform = T.Compose([T.ToTensor()])
+
+        # 4) Обрабатываем кадры
+        cap = cv2.VideoCapture(video_path)
+        max_count = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            img = transform(frame).to(device)
+            with torch.no_grad():
+                out = model([img])[0]
+            labels = out["labels"].cpu().numpy()
+            # COCO class 15 = 'bird'
+            count = int((labels == 15).sum())
+            max_count = max(max_count, count)
+        cap.release()
+
+        # 5) Удаляем временные файлы
+        os.remove(video_path)
+        os.rmdir(temp_dir)
+        return f"Максимальное число птиц в кадре: {max_count}"
+
+    async def _arun(self, text: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+
+
+

tools/youtube_tool.py

@@ -0,0 +1,61 @@
+
+# tools/youtube_tool.py
+from langchain.tools import BaseTool
+from pytube import YouTube
+import cv2
+import tempfile
+import os
+import torch
+import torchvision.transforms as T
+from torchvision.models.detection import fasterrcnn_resnet50_fpn
+
+
+class YouTubeSpeciesTool(BaseTool):
+    """
+    Инструмент для анализа видео YouTube: находит максимальное число видов птиц в кадре.
+    Использует предобученную модель Faster R-CNN на COCO для детекции птиц (COCO class 15).
+    """
+    name: str = "youtube_species"
+    description: str = (
+        "Принимает URL видео YouTube, скачивает его, "
+        "анализирует кадры и возвращает максимальное число видов птиц, "
+        "попавших в кадр одновременно."
+    )
+
+    def _run(self, url: str) -> str:
+        # Загружаем видео
+        yt = YouTube(url)
+        stream = yt.streams.filter(file_extension='mp4', progressive=True).first()
+        temp_dir = tempfile.mkdtemp()
+        video_path = stream.download(output_path=temp_dir)
+
+        # Загрузка модели
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        model = fasterrcnn_resnet50_fpn(pretrained=True).to(device)
+        model.eval()
+        transform = T.Compose([T.ToTensor()])
+
+        cap = cv2.VideoCapture(video_path)
+        max_species = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            # Преобразуем и передаем в модель
+            img = transform(frame).to(device)
+            with torch.no_grad():
+                outputs = model([img])[0]
+            # Метки классов
+            labels = outputs['labels'].cpu().numpy()
+            # COCO class 15 соответствует 'bird'
+            count = (labels == 15).sum()
+            max_species = max(max_species, int(count))
+        cap.release()
+
+        # Очистка временных файлов
+        os.remove(video_path)
+        os.rmdir(temp_dir)
+        return f"Максимальное число видов птиц в кадре: {max_species}"
+
+    async def _arun(self, url: str) -> str:
+        raise NotImplementedError("Async not supported.")

tools/youtube_transcription_tool.py

@@ -0,0 +1,51 @@
+from langchain.tools import BaseTool
+import whisper
+import tempfile
+import os
+import re
+import yt_dlp
+from config import config
+
+class YouTubeTranscriptionTool(BaseTool):
+    """
+    Инструмент для транскрипции аудио из видео YouTube.
+    Скачивает аудио через yt-dlp, обрабатывает Whisper и возвращает текст.
+    """
+    name: str = "youtube_transcribe"
+    description: str = (
+        "Скачивает аудио из YouTube по URL, транскрибирует через Whisper и возвращает текст."
+    )
+
+    def _run(self, text: str) -> str:
+        # 1) Извлекаем URL
+        m = re.search(r"(https?://[^\s,]+)", text)
+        if not m:
+            return "Ошибка: не найден корректный URL."
+        url = m.group(1)
+
+        # 2) Скачиваем аудио через yt-dlp
+        temp_dir = tempfile.mkdtemp()
+        ydl_opts = {
+            "outtmpl": os.path.join(temp_dir, "%(id)s.%(ext)s"),
+            "format": "bestaudio[ext=m4a]",
+            "quiet": True,
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+        audio_path = os.path.join(temp_dir, f"{info['id']}.m4a")
+
+        # 3) Транскрибируем через Whisper
+        model = whisper.load_model(config.WHISPER_MODEL)
+        result = model.transcribe(audio_path)
+
+        # 4) Чистим
+        os.remove(audio_path)
+        os.rmdir(temp_dir)
+        return result["text"].strip()
+
+    async def _arun(self, text: str) -> str:
+        raise NotImplementedError("Async not supported.")
+
+
+
+