Update app.py

app.py

@@ -1,21 +1,13 @@
 """
-Финальный агент для Agent Challenge (LangGraph)
+Простой агент для Agent Challenge с использованием Gradio
 """
 
 import os
-import json
 import re
 import math
-import requests
-from typing import List, Dict, Any, Optional, TypedDict, Annotated, Literal, Union
-from datetime import datetime
-
-# Импорт необходимых компонентов LangGraph
-from langgraph.graph import StateGraph, END
-from langgraph.prebuilt import ToolNode, tools_condition
-
-# Импорт инструментов LangChain
-from langchain_core.tools import tool
+import json
+import gradio as gr
+from huggingface_hub import InferenceClient
 
 # Безопасная обработка токена Hugging Face
 # Токен должен быть установлен как переменная окружения HUGGINGFACE_TOKEN
@@ -25,25 +17,17 @@ HUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN")
 # Инициализация клиента Hugging Face
 client = None
 try:
-    from huggingface_hub import InferenceClient
     client = InferenceClient(
         model="mistralai/Mixtral-8x7B-Instruct-v0.1",  # Рекомендуемая модель
-        token=HUGGINGFACE_TOKEN,
-        timeout=120  # Увеличим таймаут для больших моделей
+        token=HUGGINGFACE_TOKEN
     )
-except ImportError:
-    print("Ошибка: библиотека huggingface_hub не установлена. Установите: pip install huggingface_hub")
 except Exception as e:
     print(f"Ошибка инициализации InferenceClient: {e}. Проверьте токен и доступность модели.")
 
 # --- Определение инструментов --- 
 
-@tool
 def calculator(expression: str) -> str:
-    """Выполняет математические вычисления. 
-    Пример входа: "(2 + 3) * 4 / 2"
-    Возвращает результат вычисления или сообщение об ошибке.
-    """
+    """Выполняет математические вычисления."""
     try:
         # Ограничение на доступные функции для безопасности
         allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("__")}
@@ -52,7 +36,7 @@ def calculator(expression: str) -> str:
         allowed_names["max"] = max
         allowed_names["min"] = min
         
-        # Удаление потенциально опасных символов (хотя eval все равно рискован)
+        # Удаление потенциально опасных символов
         safe_expression = re.sub(r"[^0-9\.\+\-\*\/\(\)\s]|\b(import|exec|eval|open|lambda|\_\_)\b", "", expression)
         
         if safe_expression != expression:
@@ -63,210 +47,132 @@ def calculator(expression: str) -> str:
     except Exception as e:
         return f"Ошибка в вычислении: {str(e)}"
 
-@tool
 def web_search(query: str) -> str:
-    """Выполняет поиск в интернете по заданному запросу.
-    Пример входа: "прогноз погоды в Париже"
-    Возвращает результаты поиска (симуляция).
-    Для реального использования замените на API поисковой системы (например, Tavily, Serper).
-    """
-    print(f"--- Выполняется поиск: {query} ---")
-    # --- Симуляция поиска --- 
-    # В реальном приложении здесь будет вызов API поисковика
-    try:
-        # Пример использования requests (закомментировано, т.к. нет реального API)
-        # headers = {"X-API-KEY": os.environ.get("SEARCH_API_KEY"), "Content-Type": "application/json"}
-        # data = json.dumps({"query": query, "max_results": 3})
-        # response = requests.post("https://api.tavily.com/search", headers=headers, data=data)
-        # response.raise_for_status()
-        # results = response.json()["results"]
-        # return json.dumps(results)
-        
-        # Простая симуляция для теста
-        if "погода" in query.lower():
-            return json.dumps([{"title": "Прогноз погоды", "content": "В городе, который вы ищете, сегодня солнечно, +25C."}])
-        elif "hugging face" in query.lower():
-            return json.dumps([{"title": "Hugging Face", "content": "Hugging Face - это платформа и сообщество для работы с моделями машинного обучения."}])
-        elif "langgraph" in query.lower():
-            return json.dumps([{"title": "LangGraph", "content": "LangGraph - это библиотека для создания агентов с состоянием на основе LangChain."}])
-        else:
-            return json.dumps([{"title": "Результат поиска", "content": f"По вашему запросу '{query}' найдена общая информация."}])
-            
-    except requests.exceptions.RequestException as e:
-        return f"Ошибка сети при поиске: {e}"
-    except Exception as e:
-        return f"Ошибка при выполнении поиска: {str(e)}"
-
-@tool
-def get_current_datetime() -> str:
-    """Возвращает текущую дату и время.
-    Не требует входных данных.
-    """
-    now = datetime.now()
-    return f"Текущая дата и время: {now.strftime('%Y-%m-%d %H:%M:%S')}"
-
-# Список инструментов для агента
-tools_list = [calculator, web_search, get_current_datetime]
+    """Выполняет поиск в интернете по заданному запросу (симуляция)."""
+    # Простая симуляция для теста
+    if "погода" in query.lower():
+        return "В городе, который вы ищете, сегодня солнечно, +25C."
+    elif "hugging face" in query.lower():
+        return "Hugging Face - это платформа и сообщество для работы с моделями машинного обучения."
+    elif "python" in query.lower():
+        return "Python - высокоуровневый язык программирования общего назначения, созданный Гвидо ван Россумом."
+    else:
+        return f"По вашему запросу '{query}' найдена общая информация."
 
-# --- Определение состояния и графа --- 
-
-class AgentState(TypedDict):
-    """Состояние агента LangGraph."""
-    messages: List[Union[Dict[str, str], Any]]  # История сообщений (включая вызовы инструментов)
-
-# Узел агента (LLM для принятия решений)
-def agent_node(state: AgentState) -> Dict[str, Any]:
-    """Вызывает LLM для определения следующего шага (вызов инструмента или финальный ответ)."""
+# --- Функция для запуска агента --- 
+def run_agent(query: str) -> str:
+    """Запускает агента для ответа на вопрос."""
     if client is None:
-        raise ValueError("Клиент Hugging Face не инициализирован.")
-        
-    # Формируем промпт для LLM
-    # Важно: Промпт должен быть адаптирован под конкретную модель (Mixtral)
-    # и формат вывода инструментов LangChain/LangGraph
+        return "Ошибка: Клиент Hugging Face не инициализирован. Проверьте токен и доступность модели."
     
-    # Преобразуем state["messages"] в формат, понятный Mixtral
-    prompt_messages = []
-    for msg in state["messages"]:
-        if isinstance(msg, dict) and "role" in msg and "content" in msg:
-            prompt_messages.append(msg)
-        elif hasattr(msg, "type") and msg.type == "human":
-            prompt_messages.append({"role": "user", "content": msg.content})
-        elif hasattr(msg, "type") and msg.type == "ai":
-             # Обработка вызовов инструментов в ответе AI
-            content = msg.content
-            if hasattr(msg, "tool_calls") and msg.tool_calls:
-                tool_calls_str = json.dumps([tc["name"] for tc in msg.tool_calls])
-                content += f"\n(Вызов инструментов: {tool_calls_str})"
-            prompt_messages.append({"role": "assistant", "content": content})
-        elif hasattr(msg, "type") and msg.type == "tool":
-            prompt_messages.append({
-                "role": "tool", 
-                "content": f"Результат инструмента {msg.name}: {msg.content}",
-                "name": msg.name # Добавляем имя инструмента для контекста
-            })
-        else:
-             # Пропускаем или логируем неизвестные типы сообщений
-             print(f"Пропущено сообщение неизвестного типа: {type(msg)}")
-
-    print("--- Промпт для LLM ---")
-    # print(json.dumps(prompt_messages, indent=2, ensure_ascii=False))
-    print("...") # Не выводим весь промпт, может быть большим
+    # Определение инструментов для модели
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "calculator",
+                "description": "Выполняет математические вычисления",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "expression": {
+                            "type": "string",
+                            "description": "Математическое выражение для вычисления"
+                        }
+                    },
+                    "required": ["expression"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "web_search",
+                "description": "Ищет информацию в интернете",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "Поисковый запрос"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+    ]
     
-    # Вызов LLM
-    response = client.chat_completion(
-        messages=prompt_messages,
-        tool_choice="auto",  # Позволяем модели решать, использовать ли инструмент
-        tools=[tool.get_input_schema().schema() for tool in tools_list], # Передаем схему инструментов
-        temperature=0.1, # Низкая температура для более предсказуемых вызовов
-        max_tokens=1500
-    )
-    
-    ai_message = response["choices"][0]["message"]
+    # Начальное сообщение от пользователя
+    messages = [{"role": "user", "content": query}]
     
-    print("--- Ответ LLM ---")
-    print(ai_message)
+    # Максимальное количество итераций
+    max_iterations = 5
     
-    # Возвращаем сообщение для добавления в состояние графом
-    return {"messages": [ai_message]}
-
-# Создание графа
-workflow = StateGraph(AgentState)
-
-# Добавление узлов
-workflow.add_node("agent", agent_node)
-workflow.add_node("tools", ToolNode(tools_list))
-
-# Определение ребер
-workflow.set_entry_point("agent")
-
-# Условное ребро: после агента решаем, вызывать ли инструменты или завершать
-workflow.add_conditional_edges(
-    "agent",
-    # Функция conditions.tools_condition проверяет, есть ли tool_calls в последнем сообщении
-    tools_condition,
-    # Если есть вызовы -> к узлу tools, иначе -> к концу (END)
-    {
-        "tools": "tools",
-        END: END,
-    },
-)
-
-# Ребро от узла инструментов обратно к агенту для обработки результата
-workflow.add_edge("tools", "agent")
-
-# Компиляция графа
-agent_graph = workflow.compile()
-
-# --- Функция для запуска агента --- 
-def run_final_agent(query: str) -> str:
-    """Запускает финального агента LangGraph для ответа на вопрос."""
-    if agent_graph is None:
-        return "Ошибка: Граф агента не скомпилирован."
+    for _ in range(max_iterations):
+        # Вызов модели
+        response = client.chat_completion(
+            messages=messages,
+            tools=tools,
+            tool_choice="auto",
+            temperature=0.1,
+            max_tokens=1024
+        )
         
-    # Начальное состояние с запросом пользователя
-    initial_state = {"messages": [{"role": "user", "content": query}]}
+        # Получение ответа модели
+        assistant_message = response["choices"][0]["message"]
+        messages.append(assistant_message)
+        
+        # Проверка на наличие вызовов инструментов
+        if "tool_calls" in assistant_message and assistant_message["tool_calls"]:
+            for tool_call in assistant_message["tool_calls"]:
+                # Получение имени и аргументов инструмента
+                function_name = tool_call["function"]["name"]
+                function_args = json.loads(tool_call["function"]["arguments"])
+                
+                # Вызов соответствующего инструмента
+                if function_name == "calculator":
+                    result = calculator(function_args["expression"])
+                elif function_name == "web_search":
+                    result = web_search(function_args["query"])
+                else:
+                    result = f"Инструмент {function_name} не найден."
+                
+                # Добавление результата в сообщения
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call["id"],
+                    "name": function_name,
+                    "content": result
+                })
+        else:
+            # Если нет вызовов инструментов, возвращаем ответ
+            return assistant_message["content"]
+    
+    # Если достигнуто максимальное количество итераций, возвращаем последний ответ
+    return messages[-1]["content"]
+
+# --- Создание Gradio интерфейса ---
+def gradio_interface(query):
+    """Обработчик для Gradio интерфейса."""
+    if not query.strip():
+        return "Пожалуйста, введите вопрос."
     
-    final_state = None
     try:
-        # Запуск графа
-        final_state = agent_graph.invoke(initial_state, {"recursion_limit": 10})
-
+        response = run_agent(query)
+        return response
     except Exception as e:
-        print(f"Ошибка выполнения графа: {e}")
-        return f"Произошла ошибка во время обработки запроса: {e}"
-
-    # Извлечение финального ответа из состояния
-    if final_state and "messages" in final_state and final_state["messages"]:
-        # Ищем последнее сообщение от ассистента без вызова инструментов
-        for msg in reversed(final_state["messages"]):
-             # Проверяем, что это сообщение от AI и нет активных tool_calls
-            is_ai = (isinstance(msg, dict) and msg.get("role") == "assistant") or (hasattr(msg, "type") and msg.type == "ai")
-            has_tool_calls = (isinstance(msg, dict) and msg.get("tool_calls")) or (hasattr(msg, "tool_calls") and msg.tool_calls)
-            
-            if is_ai and not has_tool_calls:
-                return msg.get("content") if isinstance(msg, dict) else msg.content
-        
-        # Если не нашли чистого ответа, возвращаем последнее сообщение AI
-        last_ai_msg = next((m for m in reversed(final_state["messages"]) if (isinstance(m, dict) and m.get("role") == "assistant") or (hasattr(m, "type") and m.type == "ai")), None)
-        if last_ai_msg:
-             return last_ai_msg.get("content") if isinstance(last_ai_msg, dict) else last_ai_msg.content
-             
-    return "Не удалось получить финальный ответ от агента."
+        return f"Произошла ошибка: {str(e)}"
+
+# Создание интерфейса
+demo = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.Textbox(lines=2, placeholder="Введите ваш вопрос здесь..."),
+    outputs="text",
+    title="Agent Challenge - Финальный агент",
+    description="Этот агент может отвечать на вопросы, выполнять математические вычисления и искать информацию."
+)
 
-# --- API для Hugging Face Spaces --- 
-# Если запускается как веб-приложение
+# Запуск интерфейса
 if __name__ == "__main__":
-    from fastapi import FastAPI, Request
-    from fastapi.responses import JSONResponse
-    import uvicorn
-    
-    app = FastAPI(title="Agent Challenge - Финальный агент")
-    
-    @app.get("/")
-    async def root():
-        return {"message": "Агент готов к работе! Отправьте POST запрос на /agent с JSON {'query': 'ваш вопрос'}"}
-    
-    @app.post("/agent")
-    async def agent_endpoint(request: Request):
-        try:
-            data = await request.json()
-            query = data.get("query", "")
-            
-            if not query:
-                return JSONResponse(
-                    status_code=400,
-                    content={"error": "Запрос должен содержать поле 'query'"}
-                )
-            
-            response = run_final_agent(query)
-            return {"answer": response}
-            
-        except Exception as e:
-            return JSONResponse(
-                status_code=500,
-                content={"error": f"Ошибка обработки запроса: {str(e)}"}
-            )
-    
-    # Для локального запуска (не используется в Hugging Face Spaces)
-    if os.environ.get("RUN_LOCAL") == "true":
-        uvicorn.run(app, host="0.0.0.0", port=8000)
+    demo.launch()