Final_Assignment_Template

Sleeping

App Files Files Community

mdicio commited on May 17, 2025

Commit

ef7a70c

1 Parent(s): b69b087

restructuring

Browse files

Files changed (12) hide show

agent.py +47 -62
app.py +4 -5
app_template.py +0 -1
cocolabelmap.py +1 -2
fullreq.txt +309 -0
langtools.py +20 -14
requirements.txt +15 -8
setup_actions.ipynb +30 -20
tools copy.py +55 -61
tools.py +326 -241
tools_beta.py +222 -228
utils.py +11 -10

agent.py CHANGED Viewed

@@ -1,46 +1,39 @@
-from dotenv import load_dotenv
 import os
-from typing import Union, List, Dict, Any, Optional, Tuple, Bool
-# Import tools from LangChain
-from langchain.agents import get_all_tool_names
-from langchain.agents import load_tools
 # Import custom tools
 from Final_Assignment_Template.tools import (
-    ReadFileContentTool,
-    WikipediaSearchTool,
-    VisitWebpageTool,
-    TranscribeAudioTool,
-    TranscibeVideoFileTool,
-    BraveWebSearchTool,
-    DescribeImageTool,
     ArxivSearchTool,
     DownloadFileFromLinkTool,
     DuckDuckGoSearchTool,
-    AddDocumentToVectorStoreTool,
     QueryVectorStoreTool,
-    image_question_answering
 )
 # Import utility functions
-from utils import replace_tool_mentions, extract_final_answer
-# Import SmolaAgents tools
-from smolagents.default_tools import (
-    PythonInterpreterTool,
-    FinalAnswerTool
-)
-# Import models from SmolaAgents
-from smolagents import OpenAIServerModel, LiteLLMModel, CodeAgent, HfApiModel
 class BoomBot:
     def __init__(self, provider="deepinfra"):
         """
         Initialize the BoomBot with the specified provider.
         Args:
             provider (str): The model provider to use (e.g., "groq", "qwen", "gemma", "anthropic", "deepinfra", "meta")
         """
@@ -48,11 +41,11 @@ class BoomBot:
         self.provider = provider
         self.model = self._initialize_model()
         self.agent = self._create_agent()
     def _initialize_model(self):
         """
         Initialize the appropriate model based on the provider.
         Returns:
             The initialized model object
         """
@@ -60,10 +53,10 @@ class BoomBot:
             qwen_model = "ollama_chat/qwen3:8b"
             return LiteLLMModel(
                 model_id=qwen_model,
-                device='cuda',
                 num_ctx=32768,
                 temperature=0.6,
-                top_p=0.95
             )
         elif self.provider == "gemma":
             gemma_model = "ollama_chat/gemma3:12b-it-qat"
@@ -71,18 +64,14 @@ class BoomBot:
                 model_id=gemma_model,
                 num_ctx=65536,
                 temperature=1.0,
-                device='cuda',
                 top_k=64,
                 top_p=0.95,
-                min_p=0.0
             )
         elif self.provider == "anthropic":
             model_id = "anthropic/claude-3-5-sonnet-latest"
-            return LiteLLMModel(
-                model_id=model_id,
-                temperature=0.6,
-                max_tokens=8192
-            )
         elif self.provider == "deepinfra":
             deepinfra_model = "Qwen/Qwen3-235B-A22B"
             return OpenAIServerModel(
@@ -91,7 +80,7 @@ class BoomBot:
                 api_key=os.environ["DEEPINFRA_API_KEY"],
                 flatten_messages_as_text=True,
                 max_tokens=8192,
-                temperature=0.1
             )
         elif self.provider == "meta":
             meta_model = "meta-llama/Llama-3.3-70B-Instruct-Turbo"
@@ -101,23 +90,19 @@ class BoomBot:
                 api_key=os.environ["DEEPINFRA_API_KEY"],
                 flatten_messages_as_text=True,
                 max_tokens=8192,
-                temperature=0.7
             )
         elif self.provider == "groq":
             # Default to use groq's claude-3-opus or llama-3
             model_id = "claude-3-opus-20240229"
-            return LiteLLMModel(
-                model_id=model_id,
-                temperature=0.7,
-                max_tokens=8192
-            )
         else:
             raise ValueError(f"Unsupported provider: {self.provider}")
     def _create_agent(self):
         """
         Create and configure the agent with all necessary tools.
         Returns:
             The configured CodeAgent
         """
@@ -132,11 +117,11 @@ class BoomBot:
         arxiv_search = ArxivSearchTool()
         add_doc_vectorstore = AddDocumentToVectorStoreTool()
         retrieve_doc_vectorstore = QueryVectorStoreTool()
         # SmolaAgents default tools
         python_interpreter = PythonInterpreterTool()
         final_answer = FinalAnswerTool()
         # Combine all tools
         agent_tools = [
             web_searcher,
@@ -150,9 +135,9 @@ class BoomBot:
             add_doc_vectorstore,
             retrieve_doc_vectorstore,
             python_interpreter,
-            final_answer
         ]
         # Additional imports for the Python interpreter
         additional_imports = [
             "json",
@@ -178,7 +163,7 @@ class BoomBot:
             "itertools",
             "functools",
         ]
         # Create the agent
         agent = CodeAgent(
             tools=agent_tools,
@@ -186,19 +171,19 @@ class BoomBot:
             model=self.model,
             add_base_tools=False,
             stream_outputs=True,
-            additional_authorized_imports=additional_imports
         )
         # Modify the system prompt
         modified_prompt = replace_tool_mentions(agent.system_prompt)
         agent.system_prompt = modified_prompt + self._get_system_prompt()
         return agent
     def _get_system_prompt(self):
         """
         Return the system prompt for the agent.
         Returns:
             str: The system prompt
         """
@@ -260,32 +245,32 @@ class BoomBot:
           - List → comma-separated, one space (e.g., 2, 3, 4)
           - Conclude with: FINAL ANSWER: <your_answer>
         """
     def run(self, question: str, task_id: str, to_download: Bool) -> str:
         """
         Run the agent with the given question, task_id, and download flag.
         Args:
             question (str): The question or task for the agent to process
             task_id (str): A unique identifier for the task
             to_download (Bool): Flag indicating whether to download resources
         Returns:
             str: The agent's response
         """
         print(f"BoomBot running with question (first 50 chars): {question[:50]}...")
         # Configure any task-specific settings based on the parameters
         if to_download:
             # You could set up specific agent configurations here for download tasks
             pass
         # Run the agent with the given question
         result = self.agent.generate_response(question)
         # Extract the final answer from the result
         final_answer = extract_final_answer(result)
         return final_answer
@@ -293,4 +278,4 @@ class BoomBot:
 # if __name__ == "__main__":
 #     agent = BasicAgent()
 #     response = agent("What is the current population of Tokyo?", "population_query", True)
-#     print(f"Response: {response}")

 import os
+from typing import Bool
+from dotenv import load_dotenv
+# Import models from SmolaAgents
+from smolagents import CodeAgent, LiteLLMModel, OpenAIServerModel
+# Import SmolaAgents tools
+from smolagents.default_tools import FinalAnswerTool, PythonInterpreterTool
 # Import custom tools
 from Final_Assignment_Template.tools import (
+    AddDocumentToVectorStoreTool,
     ArxivSearchTool,
     DownloadFileFromLinkTool,
     DuckDuckGoSearchTool,
     QueryVectorStoreTool,
+    ReadFileContentTool,
+    TranscibeVideoFileTool,
+    TranscribeAudioTool,
+    VisitWebpageTool,
+    WikipediaSearchTool,
 )
 # Import utility functions
+from utils import extract_final_answer, replace_tool_mentions
+# Import tools from LangChain
 class BoomBot:
     def __init__(self, provider="deepinfra"):
         """
         Initialize the BoomBot with the specified provider.
         Args:
             provider (str): The model provider to use (e.g., "groq", "qwen", "gemma", "anthropic", "deepinfra", "meta")
         """
         self.provider = provider
         self.model = self._initialize_model()
         self.agent = self._create_agent()
     def _initialize_model(self):
         """
         Initialize the appropriate model based on the provider.
         Returns:
             The initialized model object
         """
             qwen_model = "ollama_chat/qwen3:8b"
             return LiteLLMModel(
                 model_id=qwen_model,
+                device="cuda",
                 num_ctx=32768,
                 temperature=0.6,
+                top_p=0.95,
             )
         elif self.provider == "gemma":
             gemma_model = "ollama_chat/gemma3:12b-it-qat"
                 model_id=gemma_model,
                 num_ctx=65536,
                 temperature=1.0,
+                device="cuda",
                 top_k=64,
                 top_p=0.95,
+                min_p=0.0,
             )
         elif self.provider == "anthropic":
             model_id = "anthropic/claude-3-5-sonnet-latest"
+            return LiteLLMModel(model_id=model_id, temperature=0.6, max_tokens=8192)
         elif self.provider == "deepinfra":
             deepinfra_model = "Qwen/Qwen3-235B-A22B"
             return OpenAIServerModel(
                 api_key=os.environ["DEEPINFRA_API_KEY"],
                 flatten_messages_as_text=True,
                 max_tokens=8192,
+                temperature=0.1,
             )
         elif self.provider == "meta":
             meta_model = "meta-llama/Llama-3.3-70B-Instruct-Turbo"
                 api_key=os.environ["DEEPINFRA_API_KEY"],
                 flatten_messages_as_text=True,
                 max_tokens=8192,
+                temperature=0.7,
             )
         elif self.provider == "groq":
             # Default to use groq's claude-3-opus or llama-3
             model_id = "claude-3-opus-20240229"
+            return LiteLLMModel(model_id=model_id, temperature=0.7, max_tokens=8192)
         else:
             raise ValueError(f"Unsupported provider: {self.provider}")
     def _create_agent(self):
         """
         Create and configure the agent with all necessary tools.
         Returns:
             The configured CodeAgent
         """
         arxiv_search = ArxivSearchTool()
         add_doc_vectorstore = AddDocumentToVectorStoreTool()
         retrieve_doc_vectorstore = QueryVectorStoreTool()
         # SmolaAgents default tools
         python_interpreter = PythonInterpreterTool()
         final_answer = FinalAnswerTool()
         # Combine all tools
         agent_tools = [
             web_searcher,
             add_doc_vectorstore,
             retrieve_doc_vectorstore,
             python_interpreter,
+            final_answer,
         ]
         # Additional imports for the Python interpreter
         additional_imports = [
             "json",
             "itertools",
             "functools",
         ]
         # Create the agent
         agent = CodeAgent(
             tools=agent_tools,
             model=self.model,
             add_base_tools=False,
             stream_outputs=True,
+            additional_authorized_imports=additional_imports,
         )
         # Modify the system prompt
         modified_prompt = replace_tool_mentions(agent.system_prompt)
         agent.system_prompt = modified_prompt + self._get_system_prompt()
         return agent
     def _get_system_prompt(self):
         """
         Return the system prompt for the agent.
         Returns:
             str: The system prompt
         """
           - List → comma-separated, one space (e.g., 2, 3, 4)
           - Conclude with: FINAL ANSWER: <your_answer>
         """
     def run(self, question: str, task_id: str, to_download: Bool) -> str:
         """
         Run the agent with the given question, task_id, and download flag.
         Args:
             question (str): The question or task for the agent to process
             task_id (str): A unique identifier for the task
             to_download (Bool): Flag indicating whether to download resources
         Returns:
             str: The agent's response
         """
         print(f"BoomBot running with question (first 50 chars): {question[:50]}...")
         # Configure any task-specific settings based on the parameters
         if to_download:
             # You could set up specific agent configurations here for download tasks
             pass
         # Run the agent with the given question
         result = self.agent.generate_response(question)
         # Extract the final answer from the result
         final_answer = extract_final_answer(result)
         return final_answer
 # if __name__ == "__main__":
 #     agent = BasicAgent()
 #     response = agent("What is the current population of Tokyo?", "population_query", True)
+#     print(f"Response: {response}")

app.py CHANGED Viewed

@@ -4,8 +4,7 @@ import os
 import gradio as gr
 import pandas as pd
 import requests
-from langchain_core.messages import HumanMessage
-from traitlets import Bool # type: ignore
 from agent import BoomBot
@@ -15,16 +14,16 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Basic Agent Definition --
-# --- Basic Agent Definition ---
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
         self.agent = BoomBot(provider="groq")
     def __call__(self, question: str, task_id: str, to_download: Bool) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         return self.agent.run(question, task_id, to_download)
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
@@ -93,7 +92,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text, task_id, to_download = to_download)
             answers_payload.append(
                 {"task_id": task_id, "submitted_answer": submitted_answer}
             )

 import gradio as gr
 import pandas as pd
 import requests
+from traitlets import Bool  # type: ignore
 from agent import BoomBot
 # --- Basic Agent Definition --
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
         self.agent = BoomBot(provider="groq")
     def __call__(self, question: str, task_id: str, to_download: Bool) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         return self.agent.run(question, task_id, to_download)
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
+            submitted_answer = agent(question_text, task_id, to_download=to_download)
             answers_payload.append(
                 {"task_id": task_id, "submitted_answer": submitted_answer}
             )

app_template.py CHANGED Viewed

@@ -1,4 +1,3 @@
-import inspect
 import os
 import gradio as gr



1	import os
2
3	import gradio as gr

cocolabelmap.py CHANGED Viewed

@@ -181,6 +181,5 @@ LABEL_MAP = {
     179: "waterdrops",
     180: "window",
     181: "window",
-    182: "wood"
 }

     179: "waterdrops",
     180: "window",
     181: "window",
+    182: "wood",
 }

fullreq.txt ADDED Viewed

	@@ -0,0 +1,309 @@

+accelerate==1.6.0
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.4
+aiohttp==3.11.18
+aiosignal==1.3.2
+alabaster==1.0.0
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.8.0
+arrow==1.3.0
+arxiv==2.2.0
+asgiref==3.8.1
+astroid==3.3.9
+asttokens==3.0.0
+attrs==25.1.0
+babel==2.17.0
+backoff==2.2.1
+bcrypt==4.2.1
+beautifulsoup4==4.12.3
+bibtexparser==1.4.3
+black==25.1.0
+blinker==1.9.0
+bs4==0.0.2
+build==1.2.2.post1
+cachetools==5.5.1
+certifi==2025.1.31
+chardet==5.2.0
+charset-normalizer==3.4.1
+chess==1.11.2
+Chroma==0.2.0
+chroma-hnswlib==0.7.6
+chromadb==1.0.9
+click==8.1.8
+colorama==0.4.6
+coloredlogs==15.0.1
+comm==0.2.2
+contourpy==1.3.2
+cssselect==1.3.0
+cycler==0.12.1
+dataclasses-json==0.6.7
+datasets==3.5.1
+debugpy==1.8.13
+decorator==5.2.1
+Deprecated==1.2.18
+dill==0.3.8
+diskcache==5.6.3
+distro==1.9.0
+docutils==0.21.2
+duckduckgo_search==8.0.2
+durationpy==0.9
+et_xmlfile==2.0.0
+executing==2.2.0
+fake-useragent==2.2.0
+fastapi==0.115.9
+feedparser==6.0.11
+ffmpy==0.5.0
+filelock==3.17.0
+flake8==7.2.0
+flatbuffers==25.1.24
+fonttools==4.58.0
+free_proxy==1.1.3
+frozenlist==1.5.0
+fsspec==2024.12.0
+gguf==0.16.3
+git-filter-repo==2.47.0
+gitdb==4.0.12
+GitPython==3.1.44
+google-auth==2.38.0
+google_search_results==2.4.2
+googleapis-common-protos==1.66.0
+gradio==5.14.0
+gradio_client==1.7.0
+greenlet==3.1.1
+grpcio==1.70.0
+h11==0.14.0
+hf-xet==1.1.0
+httpcore==1.0.7
+httptools==0.6.4
+httpx==0.27.2
+httpx-sse==0.4.0
+huggingface-hub==0.31.1
+humanfriendly==10.0
+idna==3.10
+imagesize==1.4.1
+impact-factor==1.1.2
+importlib_metadata==8.5.0
+importlib_resources==6.5.2
+iniconfig==2.1.0
+ipykernel==6.29.5
+ipython==9.1.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.7
+isort==6.0.1
+jedi==0.19.2
+Jinja2==3.1.5
+jiter==0.8.2
+joblib==1.4.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+jupyter_client==8.6.3
+jupyter_core==5.7.2
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+kubernetes==32.0.0
+langchain==0.3.25
+langchain-chroma==0.2.1
+langchain-community==0.3.16
+langchain-core==0.3.59
+langchain-huggingface==0.1.2
+langchain-tavily==0.1.6
+langchain-text-splitters==0.3.8
+langsmith==0.3.3
+litellm==1.59.10
+llama_cpp_python==0.3.9
+lxml==5.3.0
+lxml_html_clean==0.4.2
+markdown-it-py==3.0.0
+markdownify==0.14.1
+MarkupSafe==2.1.5
+marshmallow==3.26.0
+matplotlib==3.10.3
+matplotlib-inline==0.1.7
+matplotlib-venn==1.1.2
+mccabe==0.7.0
+mdurl==0.1.2
+mmh3==5.1.0
+monotonic==1.6
+mpmath==1.3.0
+multidict==6.1.0
+multiprocess==0.70.16
+mypy==1.15.0
+mypy-extensions==1.0.0
+narwhals==1.24.1
+nest-asyncio==1.6.0
+networkx==3.4.2
+numpy==1.26.4
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+oauthlib==3.2.2
+ollama==0.4.8
+onnxruntime==1.20.1
+openai==1.60.2
+opencv-python==4.11.0.86
+openpyxl==3.1.5
+opentelemetry-api==1.29.0
+opentelemetry-exporter-otlp-proto-common==1.29.0
+opentelemetry-exporter-otlp-proto-grpc==1.29.0
+opentelemetry-instrumentation==0.50b0
+opentelemetry-instrumentation-asgi==0.50b0
+opentelemetry-instrumentation-fastapi==0.50b0
+opentelemetry-proto==1.29.0
+opentelemetry-sdk==1.29.0
+opentelemetry-semantic-conventions==0.50b0
+opentelemetry-util-http==0.50b0
+orjson==3.10.15
+outcome==1.3.0.post0
+overrides==7.7.0
+packaging==24.2
+pandas==2.2.3
+paperscraper==0.3.0
+parso==0.8.4
+pathspec==0.12.1
+pexpect==4.9.0
+pillow==11.1.0
+platformdirs==4.3.7
+pluggy==1.6.0
+posthog==3.11.0
+prettytable==3.16.0
+primp==0.15.0
+prompt_toolkit==3.0.50
+propcache==0.2.1
+protobuf==5.29.3
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==19.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pycodestyle==2.13.0
+pydantic==2.10.6
+pydantic-settings==2.7.1
+pydantic_core==2.27.2
+pydeck==0.9.1
+pydub==0.25.1
+pyflakes==3.3.2
+Pygments==2.19.1
+pylint==3.3.6
+pymed_paperscraper==1.0.4
+PyMuPDF==1.25.5
+pyparsing==3.2.3
+pypdf==5.2.0
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+pyreadline3==3.5.4
+PySocks==1.7.1
+pytesseract==0.3.13
+pytest==8.3.5
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.20
+pytz==2025.1
+PyYAML==6.0.2
+pyzmq==26.4.0
+rank-bm25==0.2.2
+RapidFuzz==3.13.0
+readability-lxml==0.8.4.1
+referencing==0.36.2
+regex==2024.11.6
+requests==2.32.3
+requests-file==2.1.0
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==13.9.4
+roman-numerals-py==3.1.0
+rpds-py==0.22.3
+rsa==4.9
+ruff==0.9.4
+safehttpx==0.1.6
+safetensors==0.5.2
+scholarly==1.7.11
+scikit-learn==1.6.1
+scipy==1.15.1
+seaborn==0.13.2
+selenium==4.32.0
+semantic-version==2.10.0
+semanticscholar==0.10.0
+sentence-transformers==3.4.1
+sentencepiece==0.2.0
+sgmllib3k==1.0.0
+shellingham==1.5.4
+simple-loggers==1.0.5
+six==1.17.0
+smmap==5.0.2
+smolagents==1.15.0
+sniffio==1.3.1
+snowballstemmer==3.0.1
+sortedcontainers==2.4.0
+soupsieve==2.6
+SpeechRecognition==3.14.3
+Sphinx==8.2.3
+sphinx-rtd-theme==3.0.2
+sphinxcontrib-applehelp==2.0.0
+sphinxcontrib-devhelp==2.0.0
+sphinxcontrib-htmlhelp==2.1.0
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==2.0.0
+sphinxcontrib-serializinghtml==2.0.0
+sql-manager==1.0.5
+SQLAlchemy==2.0.37
+stack-data==0.6.3
+starlette==0.45.3
+streamlit==1.41.1
+sympy==1.14.0
+tenacity==9.0.0
+thefuzz==0.22.1
+threadpoolctl==3.5.0
+tiktoken==0.8.0
+tldextract==5.3.0
+tokenizers==0.21.0
+toml==0.10.2
+tomlkit==0.13.2
+torch==2.7.0
+torchvision==0.22.0
+tornado==6.4.2
+tqdm==4.67.1
+traitlets==5.14.3
+transformers==4.51.3
+trio==0.30.0
+trio-websocket==0.12.2
+triton==3.3.0
+typer==0.15.1
+types-python-dateutil==2.9.0.20250516
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+uvicorn==0.34.0
+uvloop==0.21.0
+watchdog==6.0.0
+watchfiles==1.0.4
+wcwidth==0.2.13
+webrequests==1.0.8
+websocket-client==1.8.0
+websockets==14.2
+whisper==1.1.10
+widgetsnbextension==4.0.14
+wikipedia==1.4.0
+Wikipedia-API==0.8.1
+wrapt==1.17.2
+wsproto==1.2.0
+xxhash==3.5.0
+yarl==1.18.3
+zipp==3.21.0
+zstandard==0.23.0

langtools.py CHANGED Viewed

@@ -1,13 +1,11 @@
-import os
 from dotenv import load_dotenv
 from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader
-from langchain_community.document_loaders import ArxivLoader
 from langchain_core.tools import tool
 load_dotenv()
 @tool
 def multiply(a: int, b: int) -> int:
     """Multiply two numbers.
@@ -17,30 +15,33 @@ def multiply(a: int, b: int) -> int:
     """
     return a * b
 @tool
 def add(a: int, b: int) -> int:
     """Add two numbers.
     Args:
         a: first int
         b: second int
     """
     return a + b
 @tool
 def subtract(a: int, b: int) -> int:
     """Subtract two numbers.
     Args:
         a: first int
         b: second int
     """
     return a - b
 @tool
 def divide(a: int, b: int) -> int:
     """Divide two numbers.
     Args:
         a: first int
         b: second int
@@ -49,20 +50,22 @@ def divide(a: int, b: int) -> int:
         raise ValueError("Cannot divide by zero.")
     return a / b
 @tool
 def modulus(a: int, b: int) -> int:
     """Get the modulus of two numbers.
     Args:
         a: first int
         b: second int
     """
     return a % b
 @tool
 def wiki_search(query: str) -> str:
     """Tool to search Wikipedia for a query about a known or historical person or subject and return maximum 2 results.
     Args:
         query: The search query."""
     search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
@@ -70,13 +73,15 @@ def wiki_search(query: str) -> str:
         [
             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
-        ])
     return {"wiki_results": formatted_search_docs}
 @tool
 def web_search(query: str) -> str:
     """Search Tavily for a query and return maximum 3 results.
     Args:
         query: The search query."""
     search_docs = TavilySearchResults(max_results=3).invoke(query=query)
@@ -84,13 +89,15 @@ def web_search(query: str) -> str:
         [
             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
-        ])
     return {"web_results": formatted_search_docs}
 @tool
 def arvix_search(query: str) -> str:
     """Tool to search Arxiv for a query about a research paper or article and return maximum 3 results.
     Args:
         query: The search query."""
     search_docs = ArxivLoader(query=query, load_max_docs=3).load()
@@ -101,4 +108,3 @@ def arvix_search(query: str) -> str:
     #     ])
     # return {"arvix_results": formatted_search_docs}
     return search_docs

 from dotenv import load_dotenv
+from langchain_community.document_loaders import ArxivLoader, WikipediaLoader
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_core.tools import tool
 load_dotenv()
 @tool
 def multiply(a: int, b: int) -> int:
     """Multiply two numbers.
     """
     return a * b
 @tool
 def add(a: int, b: int) -> int:
     """Add two numbers.
     Args:
         a: first int
         b: second int
     """
     return a + b
 @tool
 def subtract(a: int, b: int) -> int:
     """Subtract two numbers.
     Args:
         a: first int
         b: second int
     """
     return a - b
 @tool
 def divide(a: int, b: int) -> int:
     """Divide two numbers.
     Args:
         a: first int
         b: second int
         raise ValueError("Cannot divide by zero.")
     return a / b
 @tool
 def modulus(a: int, b: int) -> int:
     """Get the modulus of two numbers.
     Args:
         a: first int
         b: second int
     """
     return a % b
 @tool
 def wiki_search(query: str) -> str:
     """Tool to search Wikipedia for a query about a known or historical person or subject and return maximum 2 results.
     Args:
         query: The search query."""
     search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
         [
             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
+        ]
+    )
     return {"wiki_results": formatted_search_docs}
 @tool
 def web_search(query: str) -> str:
     """Search Tavily for a query and return maximum 3 results.
     Args:
         query: The search query."""
     search_docs = TavilySearchResults(max_results=3).invoke(query=query)
         [
             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
+        ]
+    )
     return {"web_results": formatted_search_docs}
 @tool
 def arvix_search(query: str) -> str:
     """Tool to search Arxiv for a query about a research paper or article and return maximum 3 results.
     Args:
         query: The search query."""
     search_docs = ArxivLoader(query=query, load_max_docs=3).load()
     #     ])
     # return {"arvix_results": formatted_search_docs}
     return search_docs

requirements.txt CHANGED Viewed

@@ -1,16 +1,23 @@
 gradio
-requests
 langchain
 langchain-community
 langchain-core
-langchain-google-genai
-langchain-huggingface
 langchain-groq
 langchain-tavily
-langchain-chroma
 langgraph
-huggingface_hub
-chromadb
-sentence-transformers
 python-dotenv
-protobuf==3.20.*

+beautifulsoup4
+chromadb
+duckduckgo_search
 gradio
+huggingface_hub
 langchain
+langchain-chroma
 langchain-community
 langchain-core
 langchain-groq
+langchain-huggingface
+langchain-google-genai
 langchain-tavily
 langgraph
+markdownify
+pandas
+protobuf==3.20.*
+PyMuPDF
 python-dotenv
+requests
+sentence-transformers
+smolagents
+traitlets

setup_actions.ipynb CHANGED Viewed

@@ -16,9 +16,10 @@
     }
    ],
    "source": [
-    "from dotenv import load_dotenv\n",
     "import os\n",
     "\n",
     "load_dotenv()\n",
     "token = os.getenv(\"HUGGINGFACE_TOKEN\")\n",
     "\n",
@@ -265,7 +266,13 @@
    "source": [
     "from datasets import load_dataset\n",
     "\n",
-    "dataset = load_dataset(\"gaia-benchmark/GAIA\", name=\"2023_level1\", split=\"validation\", trust_remote_code=True, cache_dir = \"ragdata\")"
    ]
   },
   {
@@ -286,7 +293,9 @@
     }
    ],
    "source": [
-    "os.listdir(r\"ragdata/gaia-benchmark___gaia/2023_level1/0.0.1/ec492fe4320ee795b1aed6bb46229c5f693226b0f1316347501c24b4baeee005\")"
    ]
   },
   {
@@ -307,11 +316,17 @@
    "source": [
     "from datasets import load_dataset\n",
     "from langchain.embeddings import HuggingFaceEmbeddings\n",
-    "from langchain.vectorstores import Chroma\n",
     "from langchain.schema import Document\n",
     "\n",
     "# Load the GAIA validation dataset\n",
-    "dataset = load_dataset(\"gaia-benchmark/GAIA\", name=\"2023_level1\", split=\"validation\", trust_remote_code=True, cache_dir = \"ragdata\")\n",
     "# Prepare the embeddings model\n",
     "embeddings = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
     "\n",
@@ -320,29 +335,24 @@
     "for entry in dataset:\n",
     "    question = entry[\"Question\"]\n",
     "    answer = entry[\"Final answer\"]\n",
-    "    \n",
     "    # Create a document with both the question and the answer as metadata\n",
     "    metadata = {\n",
     "        \"task_id\": entry[\"task_id\"],\n",
     "        \"steps\": entry[\"Annotator Metadata\"][\"Steps\"],\n",
     "        \"tools\": entry[\"Annotator Metadata\"][\"Tools\"],\n",
-    "        \"answer\": answer\n",
     "    }\n",
-    "    \n",
     "    # Add the question to the list of documents\n",
-    "    documents.append(\n",
-    "        Document(\n",
-    "            page_content=question,\n",
-    "            metadata=metadata\n",
-    "        )\n",
-    "    )\n",
     "\n",
     "# Insert the documents into Chroma\n",
     "vectorstore = Chroma.from_documents(\n",
     "    documents=documents,\n",
     "    embedding=embeddings,\n",
     "    collection_name=\"gaia_validation\",\n",
-    "    persist_directory=\"./chroma_store\"\n",
     ")\n",
     "\n",
     "# Persist the data for future use\n",
@@ -376,19 +386,19 @@
     "for entry in dataset:\n",
     "    # Access the tools used (they are stored in the 'Tools' field of 'Annotator Metadata')\n",
     "    tools = entry[\"Annotator Metadata\"][\"Tools\"]\n",
-    "    \n",
     "    # Split the tools into a list (since they are stored as a string, we split by line breaks)\n",
-    "    tools_list = tools.split('\\n')\n",
-    "    \n",
     "    # Add each tool to the set (set automatically ensures uniqueness)\n",
     "    for tool in tools_list:\n",
     "        unique_tools.add(tool.strip())  # Remove any extra spaces or newlines\n",
     "\n",
     "# Convert the set of unique tools to a dictionary under the key 'tools'\n",
-    "tools_dict = {'tools': list(unique_tools)}\n",
     "\n",
     "# Print the unique tools to get a sense of what was used\n",
-    "print(tools_dict)\n"
    ]
   },
   {

     }
    ],
    "source": [
     "import os\n",
     "\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
     "load_dotenv()\n",
     "token = os.getenv(\"HUGGINGFACE_TOKEN\")\n",
     "\n",
    "source": [
     "from datasets import load_dataset\n",
     "\n",
+    "dataset = load_dataset(\n",
+    "    \"gaia-benchmark/GAIA\",\n",
+    "    name=\"2023_level1\",\n",
+    "    split=\"validation\",\n",
+    "    trust_remote_code=True,\n",
+    "    cache_dir=\"ragdata\",\n",
+    ")"
    ]
   },
   {
     }
    ],
    "source": [
+    "os.listdir(\n",
+    "    r\"ragdata/gaia-benchmark___gaia/2023_level1/0.0.1/ec492fe4320ee795b1aed6bb46229c5f693226b0f1316347501c24b4baeee005\"\n",
+    ")"
    ]
   },
   {
    "source": [
     "from datasets import load_dataset\n",
     "from langchain.embeddings import HuggingFaceEmbeddings\n",
     "from langchain.schema import Document\n",
+    "from langchain.vectorstores import Chroma\n",
     "\n",
     "# Load the GAIA validation dataset\n",
+    "dataset = load_dataset(\n",
+    "    \"gaia-benchmark/GAIA\",\n",
+    "    name=\"2023_level1\",\n",
+    "    split=\"validation\",\n",
+    "    trust_remote_code=True,\n",
+    "    cache_dir=\"ragdata\",\n",
+    ")\n",
     "# Prepare the embeddings model\n",
     "embeddings = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
     "\n",
     "for entry in dataset:\n",
     "    question = entry[\"Question\"]\n",
     "    answer = entry[\"Final answer\"]\n",
+    "\n",
     "    # Create a document with both the question and the answer as metadata\n",
     "    metadata = {\n",
     "        \"task_id\": entry[\"task_id\"],\n",
     "        \"steps\": entry[\"Annotator Metadata\"][\"Steps\"],\n",
     "        \"tools\": entry[\"Annotator Metadata\"][\"Tools\"],\n",
+    "        \"answer\": answer,\n",
     "    }\n",
+    "\n",
     "    # Add the question to the list of documents\n",
+    "    documents.append(Document(page_content=question, metadata=metadata))\n",
     "\n",
     "# Insert the documents into Chroma\n",
     "vectorstore = Chroma.from_documents(\n",
     "    documents=documents,\n",
     "    embedding=embeddings,\n",
     "    collection_name=\"gaia_validation\",\n",
+    "    persist_directory=\"./chroma_store\",\n",
     ")\n",
     "\n",
     "# Persist the data for future use\n",
     "for entry in dataset:\n",
     "    # Access the tools used (they are stored in the 'Tools' field of 'Annotator Metadata')\n",
     "    tools = entry[\"Annotator Metadata\"][\"Tools\"]\n",
+    "\n",
     "    # Split the tools into a list (since they are stored as a string, we split by line breaks)\n",
+    "    tools_list = tools.split(\"\\n\")\n",
+    "\n",
     "    # Add each tool to the set (set automatically ensures uniqueness)\n",
     "    for tool in tools_list:\n",
     "        unique_tools.add(tool.strip())  # Remove any extra spaces or newlines\n",
     "\n",
     "# Convert the set of unique tools to a dictionary under the key 'tools'\n",
+    "tools_dict = {\"tools\": list(unique_tools)}\n",
     "\n",
     "# Print the unique tools to get a sense of what was used\n",
+    "print(tools_dict)"
    ]
   },
   {

tools copy.py CHANGED Viewed

@@ -1,18 +1,13 @@
 import os
 import re
 import tempfile
-import mimetypes
-import requests
-import pandas as pd
 import fitz  # PyMuPDF
-from urllib.parse import unquote
-from smolagents import Tool
-from smolagents import Tool
 import requests
-import traceback
-from langchain_community.retrievers import BM25Retriever
 from smolagents import Tool
-import math
 class DownloadFileFromTaskTool(Tool):
     name = "download_file_from_task"
@@ -20,15 +15,12 @@ class DownloadFileFromTaskTool(Tool):
     Use this when question requires information from a mentioned file, before reading a file."""
     inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "The GAIA task ID (REQUIRED)."
-        },
         "filename": {
             "type": "string",
             "description": "Optional custom filename to save the file as (e.g., 'data.xlsx').",
-            "nullable": True
-        }
     }
     output_type = "string"
@@ -65,15 +57,13 @@ class DownloadFileFromTaskTool(Tool):
         except Exception as e:
             return f"❌ Error: {e}"
 class ReadFileContentTool(Tool):
     name = "read_file_content"
     description = """Reads and returns the content of a file. Use after downloading a file using `download_file_from_task`."""
     inputs = {
-        "file_path": {
-            "type": "string",
-            "description": "Full path to a file to read."
-        }
     }
     output_type = "string"
@@ -124,15 +114,16 @@ class ReadFileContentTool(Tool):
         except Exception as e:
             return f"❌ Could not read {file_path}: {e}"
 class GetWikipediaInfoTool(Tool):
     name = "get_wikipedia_info"
     description = """Fetches a short summary about a topic from Wikipedia.
 Use this when a user asks for background information, an explanation, or context on a well-known subject."""
     inputs = {
         "topic": {
             "type": "string",
-            "description": "The topic to search for on Wikipedia."
         }
     }
     output_type = "string"
@@ -145,10 +136,10 @@ Use this when a user asks for background information, an explanation, or context
             search_response.raise_for_status()
             search_data = search_response.json()
-            if not search_data.get('query', {}).get('search', []):
                 return f"No Wikipedia info for '{topic}'."
-            page_id = search_data['query']['search'][0]['pageid']
             content_url = (
                 f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
@@ -158,7 +149,7 @@ Use this when a user asks for background information, an explanation, or context
             content_response.raise_for_status()
             content_data = content_response.json()
-            extract = content_data['query']['pages'][str(page_id)]['extract']
             if len(extract) > 1500:
                 extract = extract[:1500] + "..."
@@ -171,6 +162,7 @@ Use this when a user asks for background information, an explanation, or context
             traceback.print_exc()
             return f"Error wiki: {e}"
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
     description = """
@@ -181,23 +173,24 @@ class VisitWebpageTool(Tool):
     inputs = {
         "url": {
             "type": "string",
-            "description": "The full URL of the webpage to visit."
         }
     }
     output_type = "string"
     def forward(self, url: str) -> str:
         try:
             import requests
             from bs4 import BeautifulSoup
-            import json
             response = requests.get(url, timeout=10)
             response.raise_for_status()
             soup = BeautifulSoup(response.text, "html.parser")
             def clean(text):
-                return ' '.join(text.strip().split())
             def extract_tables(soup):
                 tables_data = []
@@ -254,57 +247,57 @@ class VisitWebpageTool(Tool):
         except Exception as e:
             return f"❌ Failed to fetch or parse webpage: {str(e)}"
 class TranscribeAudioTool(Tool):
     name = "transcribe_audio"
-    description = """Transcribes spoken audio (e.g. voice memos, lectures) into plain text."""
-    inputs = {
-        "file_path": {
-            "type": "string",
-            "description": "Path to an audio file."
-        }
-    }
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
-            import speech_recognition as sr
-            from pydub import AudioSegment
             import os
             import tempfile
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Convert to WAV if not already (needed for speech_recognition)
             file_ext = os.path.splitext(file_path)[1].lower()
-            if file_ext != '.wav':
                 # Create temp WAV file
-                temp_wav = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
                 # Convert to WAV using pydub
                 audio = AudioSegment.from_file(file_path)
                 audio.export(temp_wav, format="wav")
                 audio_path = temp_wav
             else:
                 audio_path = file_path
             # Transcribe audio using Google's speech recognition
             with sr.AudioFile(audio_path) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file if created
-            if file_ext != '.wav' and os.path.exists(temp_wav):
                 os.remove(temp_wav)
             return transcript.strip()
         except Exception as e:
             return f"❌ Transcription failed: {str(e)}"
 class TranscibeVideoFileTool(Tool):
     name = "transcribe_video"
     description = """Transcribes speech from a video file. Use this to understand video lectures, tutorials, or visual demos."""
@@ -312,41 +305,42 @@ class TranscibeVideoFileTool(Tool):
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "Path to the video file (e.g., .mp4, .mov)."
         }
     }
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
-            import moviepy.editor as mp
-            import speech_recognition as sr
             import os
             import tempfile
             # Extract audio from video
             video = mp.VideoFileClip(file_path)
             # Create temporary audio file
-            temp_audio = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
             # Extract audio to WAV format (required for speech_recognition)
             video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
             video.close()
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Transcribe audio
             with sr.AudioFile(temp_audio) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file
             if os.path.exists(temp_audio):
                 os.remove(temp_audio)
             return transcript.strip()
         except Exception as e:
-            return f"❌ Video processing failed: {str(e)}"

 import os
 import re
 import tempfile
+import traceback
 import fitz  # PyMuPDF
+import pandas as pd
 import requests
 from smolagents import Tool
 class DownloadFileFromTaskTool(Tool):
     name = "download_file_from_task"
     Use this when question requires information from a mentioned file, before reading a file."""
     inputs = {
+        "task_id": {"type": "string", "description": "The GAIA task ID (REQUIRED)."},
         "filename": {
             "type": "string",
             "description": "Optional custom filename to save the file as (e.g., 'data.xlsx').",
+            "nullable": True,
+        },
     }
     output_type = "string"
         except Exception as e:
             return f"❌ Error: {e}"
 class ReadFileContentTool(Tool):
     name = "read_file_content"
     description = """Reads and returns the content of a file. Use after downloading a file using `download_file_from_task`."""
     inputs = {
+        "file_path": {"type": "string", "description": "Full path to a file to read."}
     }
     output_type = "string"
         except Exception as e:
             return f"❌ Could not read {file_path}: {e}"
 class GetWikipediaInfoTool(Tool):
     name = "get_wikipedia_info"
     description = """Fetches a short summary about a topic from Wikipedia.
 Use this when a user asks for background information, an explanation, or context on a well-known subject."""
     inputs = {
         "topic": {
             "type": "string",
+            "description": "The topic to search for on Wikipedia.",
         }
     }
     output_type = "string"
             search_response.raise_for_status()
             search_data = search_response.json()
+            if not search_data.get("query", {}).get("search", []):
                 return f"No Wikipedia info for '{topic}'."
+            page_id = search_data["query"]["search"][0]["pageid"]
             content_url = (
                 f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
             content_response.raise_for_status()
             content_data = content_response.json()
+            extract = content_data["query"]["pages"][str(page_id)]["extract"]
             if len(extract) > 1500:
                 extract = extract[:1500] + "..."
             traceback.print_exc()
             return f"Error wiki: {e}"
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
     description = """
     inputs = {
         "url": {
             "type": "string",
+            "description": "The full URL of the webpage to visit.",
         }
     }
     output_type = "string"
     def forward(self, url: str) -> str:
         try:
+            import json
             import requests
             from bs4 import BeautifulSoup
             response = requests.get(url, timeout=10)
             response.raise_for_status()
             soup = BeautifulSoup(response.text, "html.parser")
             def clean(text):
+                return " ".join(text.strip().split())
             def extract_tables(soup):
                 tables_data = []
         except Exception as e:
             return f"❌ Failed to fetch or parse webpage: {str(e)}"
 class TranscribeAudioTool(Tool):
     name = "transcribe_audio"
+    description = (
+        """Transcribes spoken audio (e.g. voice memos, lectures) into plain text."""
+    )
+    inputs = {"file_path": {"type": "string", "description": "Path to an audio file."}}
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
             import os
             import tempfile
+            import speech_recognition as sr
+            from pydub import AudioSegment
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Convert to WAV if not already (needed for speech_recognition)
             file_ext = os.path.splitext(file_path)[1].lower()
+            if file_ext != ".wav":
                 # Create temp WAV file
+                temp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
                 # Convert to WAV using pydub
                 audio = AudioSegment.from_file(file_path)
                 audio.export(temp_wav, format="wav")
                 audio_path = temp_wav
             else:
                 audio_path = file_path
             # Transcribe audio using Google's speech recognition
             with sr.AudioFile(audio_path) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file if created
+            if file_ext != ".wav" and os.path.exists(temp_wav):
                 os.remove(temp_wav)
             return transcript.strip()
         except Exception as e:
             return f"❌ Transcription failed: {str(e)}"
 class TranscibeVideoFileTool(Tool):
     name = "transcribe_video"
     description = """Transcribes speech from a video file. Use this to understand video lectures, tutorials, or visual demos."""
     inputs = {
         "file_path": {
             "type": "string",
+            "description": "Path to the video file (e.g., .mp4, .mov).",
         }
     }
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
             import os
             import tempfile
+            import moviepy.editor as mp
+            import speech_recognition as sr
             # Extract audio from video
             video = mp.VideoFileClip(file_path)
             # Create temporary audio file
+            temp_audio = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
             # Extract audio to WAV format (required for speech_recognition)
             video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
             video.close()
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Transcribe audio
             with sr.AudioFile(temp_audio) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file
             if os.path.exists(temp_audio):
                 os.remove(temp_audio)
             return transcript.strip()
         except Exception as e:
+            return f"❌ Video processing failed: {str(e)}"

tools.py CHANGED Viewed

@@ -1,71 +1,41 @@
-import os
-import re
-import tempfile
-import mimetypes
-import requests
-import pandas as pd
-import fitz  # PyMuPDF
-from urllib.parse import unquote
-from smolagents import Tool
-import requests
-import traceback
-import math
-from langchain_community.tools import BraveSearch
-from typing import List, Dict
-import json
-import html
-import requests, cv2, numpy as np, os
 import html
 import json
-import requests
-from bs4 import BeautifulSoup
-from langchain_community.document_loaders import ArxivLoader
-import arxiv
-from smolagents import tool
-from smolagents.tools import Tool
-import requests
-import os
 import mimetypes
 import traceback
 from urllib.parse import urlparse
-import time
-import traceback
 from duckduckgo_search import DDGS
 from duckduckgo_search.exceptions import (
     DuckDuckGoSearchException,
     RatelimitException,
     TimeoutException,
-    ConversationLimitException,
 )
-from smolagents.tools import Tool
-import chromadb
-from pathlib import Path
-import traceback
-import json
-import os
 from langchain.document_loaders import (
-    TextLoader, PyPDFLoader, JSONLoader, UnstructuredFileLoader,BSHTMLLoader
 )
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-import chromadb.utils.embedding_functions as embedding_functions
-import os
-import pandas as pd
-import fitz  # PyMuPDF
-from markdownify import markdownify
-from bs4 import BeautifulSoup
-import re
-from smolagents.utils import truncate_content
-import requests
-from bs4 import BeautifulSoup
 from markdownify import markdownify
-import re
 from smolagents.utils import truncate_content
 class ReadFileContentTool(Tool):
     name = "read_file_content"
     description = """Reads local files in various formats (text, CSV, Excel, PDF, HTML, etc.) and returns their content as readable text. Automatically detects and processes the appropriate file format."""
@@ -73,7 +43,7 @@ class ReadFileContentTool(Tool):
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "The full path to the file from which the content should be read."
         }
     }
     output_type = "string"
@@ -91,17 +61,23 @@ class ReadFileContentTool(Tool):
             elif ext == ".csv":
                 df = pd.read_csv(file_path)
-                return truncate_content(f"CSV Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}")
             elif ext in [".xlsx", ".xls"]:
                 df = pd.read_excel(file_path)
-                return truncate_content(f"Excel Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}")
             elif ext == ".pdf":
                 doc = fitz.open(file_path)
                 text = "".join([page.get_text() for page in doc])
                 doc.close()
-                return truncate_content(text.strip() or "⚠️ PDF contains no readable text.")
             elif ext == ".json":
                 with open(file_path, "r", encoding="utf-8") as f:
@@ -135,6 +111,7 @@ class ReadFileContentTool(Tool):
         except Exception as e:
             return f"❌ Could not read {file_path}: {e}"
 class WikipediaSearchTool(Tool):
     name = "wikipedia_search"
     description = """Searches Wikipedia for a specific topic and returns a concise summary. Useful for background information on subjects, concepts, historical events, or scientific topics."""
@@ -142,7 +119,7 @@ class WikipediaSearchTool(Tool):
     inputs = {
         "query": {
             "type": "string",
-            "description": "The query or subject to search for on Wikipedia."
         }
     }
     output_type = "string"
@@ -155,10 +132,10 @@ class WikipediaSearchTool(Tool):
             search_response.raise_for_status()
             search_data = search_response.json()
-            if not search_data.get('query', {}).get('search', []):
                 return f"No Wikipedia info for '{query}'."
-            page_id = search_data['query']['search'][0]['pageid']
             content_link = (
                 f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
@@ -168,7 +145,7 @@ class WikipediaSearchTool(Tool):
             content_response.raise_for_status()
             content_data = content_response.json()
-            extract = content_data['query']['pages'][str(page_id)]['extract']
             if len(extract) > 1500:
                 extract = extract[:1500] + "..."
@@ -181,11 +158,10 @@ class WikipediaSearchTool(Tool):
             traceback.print_exc()
             return f"Error wiki: {e}"
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
-    description = (
-        "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
-    )
     inputs = {
         "url": {
             "type": "string",
@@ -201,7 +177,6 @@ class VisitWebpageTool(Tool):
             import requests
             from markdownify import markdownify
             from requests.exceptions import RequestException
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(
@@ -220,7 +195,8 @@ class VisitWebpageTool(Tool):
             return f"Error fetching the webpage: {str(e)}"
         except Exception as e:
             return f"An unexpected error occurred: {str(e)}"
 class TranscribeAudioTool(Tool):
     name = "transcribe_audio"
     description = """Converts spoken content in audio files to text. Handles various audio formats and produces a transcript of the spoken content for analysis."""
@@ -228,54 +204,57 @@ class TranscribeAudioTool(Tool):
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "The full path to the audio file that needs to be transcribed."
         }
     }
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
-            import speech_recognition as sr
-            from pydub import AudioSegment
             import os
             import tempfile
             # Verify file exists
             if not os.path.exists(file_path):
-                return f"❌ Audio file not found at: {file_path}. Download the file first."
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Convert to WAV if not already (needed for speech_recognition)
             file_ext = os.path.splitext(file_path)[1].lower()
-            if file_ext != '.wav':
                 # Create temp WAV file
-                temp_wav = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
                 # Convert to WAV using pydub
                 audio = AudioSegment.from_file(file_path)
                 audio.export(temp_wav, format="wav")
                 audio_path = temp_wav
             else:
                 audio_path = file_path
             # Transcribe audio using Google's speech recognition
             with sr.AudioFile(audio_path) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file if created
-            if file_ext != '.wav' and os.path.exists(temp_wav):
                 os.remove(temp_wav)
             return transcript.strip()
         except Exception as e:
             return f"❌ Transcription failed: {str(e)}"
 class TranscibeVideoFileTool(Tool):
     name = "transcribe_video"
     description = """Extracts and transcribes speech from video files. Converts the audio portion of videos into readable text for analysis or reference."""
@@ -283,7 +262,7 @@ class TranscibeVideoFileTool(Tool):
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "The full path to the video file that needs to be transcribed."
         }
     }
     output_type = "string"
@@ -292,40 +271,44 @@ class TranscibeVideoFileTool(Tool):
         try:
             # Verify file exists
             if not os.path.exists(file_path):
-                return f"❌ Video file not found at: {file_path}. Download the file first."
-            import moviepy.editor as mp
-            import speech_recognition as sr
             import os
             import tempfile
             # Extract audio from video
             video = mp.VideoFileClip(file_path)
             # Create temporary audio file
-            temp_audio = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
             # Extract audio to WAV format (required for speech_recognition)
             video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
             video.close()
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Transcribe audio
             with sr.AudioFile(temp_audio) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file
             if os.path.exists(temp_audio):
                 os.remove(temp_audio)
             return transcript.strip()
         except Exception as e:
             return f"❌ Video processing failed: {str(e)}"
 class BraveWebSearchTool(Tool):
     name = "web_search"
     description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
@@ -333,7 +316,7 @@ class BraveWebSearchTool(Tool):
     inputs = {
         "query": {
             "type": "string",
-            "description": "A web search query string (e.g., a question or query)."
         }
     }
     output_type = "string"
@@ -366,10 +349,14 @@ class BraveWebSearchTool(Tool):
     def forward(self, query: str) -> str:
         try:
             results_json = self.tool.run(query)
-            results = json.loads(results_json) if isinstance(results_json, str) else results_json
             output_parts = []
-            for i, r in enumerate(results[:self.count], start=1):
                 title = html.unescape(r.get("title", "").strip())
                 link = r.get("link", "").strip()
@@ -388,6 +375,7 @@ class BraveWebSearchTool(Tool):
         except Exception as e:
             return f"Search failed: {str(e)}"
 class DescribeImageTool(Tool):
     name = "describe_image"
     description = """Analyzes images and generates detailed text descriptions. Identifies objects, scenes, text, and visual elements within the image to provide context or understanding."""
@@ -395,23 +383,27 @@ class DescribeImageTool(Tool):
     inputs = {
         "image_path": {
             "type": "string",
-            "description": "The full path to the image file to describe."
         }
     }
     output_type = "string"
     def forward(self, image_path: str) -> str:
         import os
         from PIL import Image
-        import torch
-        from transformers import BlipProcessor, BlipForConditionalGeneration
         if not os.path.exists(image_path):
             return f"❌ Image file does not exist: {image_path}"
         try:
-            processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base", use_fast = True)
-            model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
             image = Image.open(image_path).convert("RGB")
             inputs = processor(images=image, return_tensors="pt")
@@ -422,24 +414,37 @@ class DescribeImageTool(Tool):
         except Exception as e:
             return f"❌ Failed to describe image: {e}"
 class DownloadFileFromLinkTool(Tool):
     name = "download_file_from_link"
     description = "Downloads files from a URL and saves them locally. Supports various formats including PDFs, documents, images, and data files. Returns the local file path for further processing."
     inputs = {
-        "link": {
-            "type": "string",
-            "description": "The URL to download the file from."
-        },
         "file_name": {
             "type": "string",
             "description": "Desired name of the saved file, without extension.",
-            "nullable": True
-        }
     }
     output_type = "string"
-    SUPPORTED_EXTENSIONS = {'.xlsx','.pdf', '.txt', '.csv', '.json', '.xml', '.html', '.jpg', '.jpeg', '.png', '.mp4', '.mp3', '.wav', '.zip'}
     def forward(self, link: str, file_name: str = "taskfile") -> str:
         print(f"⬇️ Downloading file from: {link}")
@@ -452,7 +457,9 @@ class DownloadFileFromLinkTool(Tool):
             return f"❌ Error: Request failed - {e}"
         if response.status_code != 200:
-            return f"❌ Error: Unable to fetch file. Status code: {response.status_code}"
         # Step 1: Try extracting extension from provided filename
         base_name, provided_ext = os.path.splitext(file_name)
@@ -463,7 +470,9 @@ class DownloadFileFromLinkTool(Tool):
             ext = provided_ext
         else:
             # Step 3: Try to infer from Content-Type
-            content_type = response.headers.get("Content-Type", "").split(";")[0].strip()
             guessed_ext = mimetypes.guess_extension(content_type or "") or ""
             # Step 4: If mimetype returned .bin or nothing useful, try to fallback to URL
@@ -489,6 +498,7 @@ class DownloadFileFromLinkTool(Tool):
         return file_path
 class DuckDuckGoSearchTool(Tool):
     name = "web_search"
     description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
@@ -496,7 +506,7 @@ class DuckDuckGoSearchTool(Tool):
     inputs = {
         "query": {
             "type": "string",
-            "description": "The search query to run on DuckDuckGo"
         },
     }
     output_type = "string"
@@ -507,7 +517,9 @@ class DuckDuckGoSearchTool(Tool):
     def forward(self, query: str) -> str:
         self._configure()
-        print(f"EXECUTING TOOL: duckduckgo_search(query='{query}', top_results={top_results})")
         top_results = 5
@@ -532,7 +544,7 @@ class DuckDuckGoSearchTool(Tool):
                     title = res.get("title", "N/A")
                     url = res.get("href", "N/A")
                     snippet = res.get("body", "N/A")
                     output_lines.append(
                         f"Result {idx}:\n"
                         f"Title: {title}\n"
@@ -545,9 +557,16 @@ class DuckDuckGoSearchTool(Tool):
                 print(f"-> Tool Result (DuckDuckGo): {output[:1500]}...")
                 return output
-            except (DuckDuckGoSearchException, TimeoutException, RatelimitException, ConversationLimitException) as e:
                 retries += 1
-                print(f"⚠️ DuckDuckGo Exception (Attempt {retries}/{max_retries}): {type(e).__name__}: {e}")
                 traceback.print_exc()
                 time.sleep(retry_sleep)
@@ -557,12 +576,22 @@ class DuckDuckGoSearchTool(Tool):
                 return f"Unhandled exception during DuckDuckGo search: {e}"
         return f"❌ Failed to retrieve results after {max_retries} retries."
 huggingface_ef = embedding_functions.HuggingFaceEmbeddingFunction(
-    api_key=os.environ["HF_TOKEN"],
-    model_name="sentence-transformers/all-mpnet-base-v2"
 )
-SUPPORTED_EXTENSIONS = [".txt", ".md", ".py", ".pdf", ".json", ".jsonl", '.html', '.htm']
 class AddDocumentToVectorStoreTool(Tool):
     name = "add_document_to_vector_store"
@@ -599,16 +628,21 @@ class AddDocumentToVectorStoreTool(Tool):
                 return f"Unsupported or missing file: {file_path}"
             docs = self._load_file(path)
-            text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
             split_docs = text_splitter.split_documents(docs)
-            client = chromadb.Client(chromadb.config.Settings(
-                persist_directory="./chroma_store",
-            ))
-            collection = client.get_or_create_collection(name=collection_name,configuration={
-        "embedding_function": huggingface_ef
-    })
             texts = [doc.page_content for doc in split_docs]
             metadatas = [doc.metadata for doc in split_docs]
@@ -616,7 +650,7 @@ class AddDocumentToVectorStoreTool(Tool):
             collection.add(
                 documents=texts,
                 metadatas=metadatas,
-                ids=[f"{path.stem}_{i}" for i in range(len(texts))]
             )
             return f"✅ Successfully added {len(texts)} chunks from '{file_path}' to collection '{collection_name}'."
@@ -625,7 +659,8 @@ class AddDocumentToVectorStoreTool(Tool):
             print(f"❌ Error in add_to_vector_store: {e}")
             traceback.print_exc()
             return f"Error: {e}"
 class QueryVectorStoreTool(Tool):
     name = "query_downloaded_documents"
     description = "Performs semantic searches across your downloaded documents. Use detailed queries to find specific information, concepts, or answers from your collected resources."
@@ -638,8 +673,8 @@ class QueryVectorStoreTool(Tool):
         "top_k": {
             "type": "integer",
             "description": "Number of top results to retrieve. Usually between 3 and 30",
-            "nullable": True
-        }
     }
     output_type = "string"
@@ -653,9 +688,11 @@ class QueryVectorStoreTool(Tool):
         print(f"🔎 Querying vector store '{collection_name}' with: '{query}'")
         try:
-            client = chromadb.Client(chromadb.config.Settings(
-                persist_directory="./chroma_store",
-            ))
             collection = client.get_collection(name=collection_name)
             results = collection.query(
@@ -668,9 +705,7 @@ class QueryVectorStoreTool(Tool):
                 doc = results["documents"][0][i]
                 metadata = results["metadatas"][0][i]
                 formatted.append(
-                    f"Result {i+1}:\n"
-                    f"Content: {doc}\n"
-                    f"Metadata: {metadata}\n"
                 )
             return "\n".join(formatted) or "No relevant documents found."
@@ -680,15 +715,16 @@ class QueryVectorStoreTool(Tool):
             traceback.print_exc()
             return f"Error querying vector store: {e}"
 @tool
 def image_question_answering(image_path: str, prompt: str) -> str:
     """
     Analyzes images and answers specific questions about their content. Can identify objects, read text, describe scenes, or interpret visual information based on your questions.
     Args:
         image_path: The path to the image file
         prompt: The question to ask about the image
     Returns:
         A string answer generated by the local Ollama model
     """
@@ -703,15 +739,15 @@ def image_question_answering(image_path: str, prompt: str) -> str:
     # Send the image and prompt to Ollama's local model
     response = chat(
-        model='llava',  # Assuming your model is named 'lava'
         messages=[
             {
-                'role': 'user',
-                'content': prompt,
-                'images': [path],
             },
         ],
-        options={'temperature': 0.2}  # Slight randomness for naturalness
     )
     return response.message.content.strip()
@@ -719,9 +755,7 @@ def image_question_answering(image_path: str, prompt: str) -> str:
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
-    description = (
-        "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
-    )
     inputs = {
         "url": {
             "type": "string",
@@ -732,53 +766,51 @@ class VisitWebpageTool(Tool):
     def forward(self, url: str) -> str:
         try:
-            import re
             from urllib.parse import urlparse
             import requests
             from bs4 import BeautifulSoup
             from markdownify import markdownify
             from requests.exceptions import RequestException
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(
                 "You must install packages `markdownify`, `requests`, and `beautifulsoup4` to run this tool: for instance run `pip install markdownify requests beautifulsoup4`."
             ) from e
         try:
             # Get the webpage content
             headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
             }
             response = requests.get(url, headers=headers, timeout=20)
             response.raise_for_status()
             # Parse the HTML with BeautifulSoup
-            soup = BeautifulSoup(response.text, 'html.parser')
             # Extract domain name for context
             domain = urlparse(url).netloc
             # Remove common clutter elements
             self._remove_clutter(soup)
             # Try to identify and prioritize main content
             main_content = self._extract_main_content(soup)
             if main_content:
                 # Convert the cleaned HTML to markdown
                 markdown_content = markdownify(str(main_content)).strip()
             else:
                 # Fallback to full page content if main content extraction fails
                 markdown_content = markdownify(str(soup)).strip()
             # Post-process the markdown content
             markdown_content = self._clean_markdown(markdown_content)
             # Add source information
             result = f"Content from {domain}:\n\n{markdown_content}"
             return truncate_content(result, 40000)
         except requests.exceptions.Timeout:
@@ -787,47 +819,75 @@ class VisitWebpageTool(Tool):
             return f"Error fetching the webpage: {str(e)}"
         except Exception as e:
             return f"An unexpected error occurred: {str(e)}"
     def _remove_clutter(self, soup):
         """Remove common elements that clutter web pages."""
         # Common non-content elements to remove
         clutter_selectors = [
-            'header', 'footer', 'nav', '.nav', '.navigation', '.menu', '.sidebar',
-            '.footer', '.header', '#footer', '#header', '#nav', '#sidebar',
-            '.widget', '.cookie', '.cookies', '.ad', '.ads', '.advertisement',
-            'script', 'style', 'noscript', 'iframe', '.social', '.share',
-            '.comment', '.comments', '.subscription', '.newsletter',
-            '[role="banner"]', '[role="navigation"]', '[role="complementary"]'
         ]
         for selector in clutter_selectors:
             for element in soup.select(selector):
                 element.decompose()
         # Remove hidden elements
-        for hidden in soup.select('[style*="display: none"], [style*="display:none"], [style*="visibility: hidden"], [style*="visibility:hidden"], [hidden]'):
             hidden.decompose()
     def _extract_main_content(self, soup):
         """Try to identify and extract the main content of the page."""
         # Priority order for common main content containers
         main_content_selectors = [
-            'main',
-            '[role="main"]',
-            'article',
-            '.content',
-            '.main-content',
-            '.post-content',
-            '#content',
-            '#main',
-            '#main-content',
-            '.article',
-            '.post',
-            '.entry',
-            '.page-content',
-            '.entry-content',
         ]
         # Try to find the main content container
         for selector in main_content_selectors:
             main_content = soup.select(selector)
@@ -836,9 +896,9 @@ class VisitWebpageTool(Tool):
                 if len(main_content) > 1:
                     return max(main_content, key=lambda x: len(x.get_text()))
                 return main_content[0]
         # If no main content container found, look for the largest text block
-        paragraphs = soup.find_all('p')
         if paragraphs:
             # Find the parent that contains the most paragraphs
             parents = {}
@@ -847,88 +907,106 @@ class VisitWebpageTool(Tool):
                     if p.parent not in parents:
                         parents[p.parent] = 0
                     parents[p.parent] += 1
             if parents:
                 # Return the parent with the most paragraphs
                 return max(parents.items(), key=lambda x: x[1])[0]
         # Return None if we can't identify main content
         return None
     def _clean_markdown(self, content):
         """Clean up the markdown content."""
         # Normalize whitespace
-        content = re.sub(r'\n{3,}', '\n\n', content)
         # Remove consecutive duplicate links
-        content = re.sub(r'(\[.*?\]\(.*?\))\s*\1+', r'\1', content)
         # Remove very short lines that are likely menu items
-        lines = content.split('\n')
         filtered_lines = []
         # Skip consecutive short lines (likely menus)
         short_line_threshold = 40  # characters
         consecutive_short_lines = 0
         max_consecutive_short_lines = 3
         for line in lines:
             stripped_line = line.strip()
-            if len(stripped_line) < short_line_threshold and not stripped_line.startswith('#'):
                 consecutive_short_lines += 1
                 if consecutive_short_lines > max_consecutive_short_lines:
                     continue
             else:
                 consecutive_short_lines = 0
             filtered_lines.append(line)
-        content = '\n'.join(filtered_lines)
         # Remove duplicate headers
         seen_headers = set()
-        lines = content.split('\n')
         filtered_lines = []
         for line in lines:
-            if line.startswith('#'):
                 header_text = line.strip()
                 if header_text in seen_headers:
                     continue
                 seen_headers.add(header_text)
             filtered_lines.append(line)
-        content = '\n'.join(filtered_lines)
         # Remove lines containing common footer patterns
         footer_patterns = [
-            r'^copyright', r'^©', r'^all rights reserved',
-            r'^terms', r'^privacy policy', r'^contact us',
-            r'^follow us', r'^social media', r'^disclaimer',
         ]
-        footer_pattern = '|'.join(footer_patterns)
-        lines = content.split('\n')
         filtered_lines = []
         for line in lines:
             if not re.search(footer_pattern, line.lower()):
                 filtered_lines.append(line)
-        content = '\n'.join(filtered_lines)
         return content
 class ArxivSearchTool(Tool):
     name = "arxiv_search"
     description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, abstracts, and download links."""
     inputs = {
-        "query":    {"type": "string",  "description": "A research-related query (e.g., 'AI regulation')"},
-        "from_date":{"type": "string",  "description": "Optional search start date in format (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')", "nullable": True},
-        "to_date":  {"type": "string",  "description": "Optional search end date in (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')", "nullable": True},
     }
     output_type = "string"
@@ -962,15 +1040,17 @@ class ArxivSearchTool(Tool):
                 f"Summary      : {p['abstract'][:500]}{'...' if len(p['abstract'])>500 else ''}",
                 f"Entry ID     : {p['entry_link']}",
                 f"Download link: {p['download_link']}",
-                ""
             ]
         return "\n".join(output_lines).strip()
 import requests
 from bs4 import BeautifulSoup
-from typing import List, Dict
 def fetch_and_parse_arxiv(url: str) -> List[Dict[str, str]]:
     """
@@ -999,7 +1079,9 @@ def fetch_and_parse_arxiv(url: str) -> List[Dict[str, str]]:
         # Abstract
         ab = li.find("span", class_="abstract-full")
-        abstract = ab.get_text(strip=True).replace("Abstract:", "").strip() if ab else ""
         # Published date
         d = li.find("p", class_="is-size-7")
@@ -1017,24 +1099,27 @@ def fetch_and_parse_arxiv(url: str) -> List[Dict[str, str]]:
                     doi = a_tag["href"]
                     break
-        results.append({
-            "title": title,
-            "authors": authors,
-            "published": published,
-            "abstract": abstract,
-            "entry_link": entry_link,
-            "download_link": entry_link.replace("abs", "pdf") if "abs" in entry_link else "N/A"
-        })
     return results
 from urllib.parse import quote_plus
 def build_arxiv_url(
-    query: str,
-    from_date: str = None,
-    to_date: str = None,
-    size: int = 50
 ) -> str:
     """
     Build an arXiv advanced-search URL matching the exact segment order:

 import html
 import json
 import mimetypes
+import os
+import re
+import time
 import traceback
+from pathlib import Path
+from typing import Dict, List
 from urllib.parse import urlparse
+import chromadb
+import chromadb.utils.embedding_functions as embedding_functions
+import fitz  # PyMuPDF
+import pandas as pd
+import requests
+from bs4 import BeautifulSoup
 from duckduckgo_search import DDGS
 from duckduckgo_search.exceptions import (
+    ConversationLimitException,
     DuckDuckGoSearchException,
     RatelimitException,
     TimeoutException,
 )
 from langchain.document_loaders import (
+    BSHTMLLoader,
+    JSONLoader,
+    PyPDFLoader,
+    TextLoader,
+    UnstructuredFileLoader,
 )
 from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.tools import BraveSearch
 from markdownify import markdownify
+from smolagents import Tool, tool
 from smolagents.utils import truncate_content
 class ReadFileContentTool(Tool):
     name = "read_file_content"
     description = """Reads local files in various formats (text, CSV, Excel, PDF, HTML, etc.) and returns their content as readable text. Automatically detects and processes the appropriate file format."""
     inputs = {
         "file_path": {
             "type": "string",
+            "description": "The full path to the file from which the content should be read.",
         }
     }
     output_type = "string"
             elif ext == ".csv":
                 df = pd.read_csv(file_path)
+                return truncate_content(
+                    f"CSV Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}"
+                )
             elif ext in [".xlsx", ".xls"]:
                 df = pd.read_excel(file_path)
+                return truncate_content(
+                    f"Excel Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}"
+                )
             elif ext == ".pdf":
                 doc = fitz.open(file_path)
                 text = "".join([page.get_text() for page in doc])
                 doc.close()
+                return truncate_content(
+                    text.strip() or "⚠️ PDF contains no readable text."
+                )
             elif ext == ".json":
                 with open(file_path, "r", encoding="utf-8") as f:
         except Exception as e:
             return f"❌ Could not read {file_path}: {e}"
 class WikipediaSearchTool(Tool):
     name = "wikipedia_search"
     description = """Searches Wikipedia for a specific topic and returns a concise summary. Useful for background information on subjects, concepts, historical events, or scientific topics."""
     inputs = {
         "query": {
             "type": "string",
+            "description": "The query or subject to search for on Wikipedia.",
         }
     }
     output_type = "string"
             search_response.raise_for_status()
             search_data = search_response.json()
+            if not search_data.get("query", {}).get("search", []):
                 return f"No Wikipedia info for '{query}'."
+            page_id = search_data["query"]["search"][0]["pageid"]
             content_link = (
                 f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
             content_response.raise_for_status()
             content_data = content_response.json()
+            extract = content_data["query"]["pages"][str(page_id)]["extract"]
             if len(extract) > 1500:
                 extract = extract[:1500] + "..."
             traceback.print_exc()
             return f"Error wiki: {e}"
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
+    description = "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
     inputs = {
         "url": {
             "type": "string",
             import requests
             from markdownify import markdownify
             from requests.exceptions import RequestException
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(
             return f"Error fetching the webpage: {str(e)}"
         except Exception as e:
             return f"An unexpected error occurred: {str(e)}"
 class TranscribeAudioTool(Tool):
     name = "transcribe_audio"
     description = """Converts spoken content in audio files to text. Handles various audio formats and produces a transcript of the spoken content for analysis."""
     inputs = {
         "file_path": {
             "type": "string",
+            "description": "The full path to the audio file that needs to be transcribed.",
         }
     }
     output_type = "string"
     def forward(self, file_path: str) -> str:
         try:
             import os
             import tempfile
+            import speech_recognition as sr
+            from pydub import AudioSegment
             # Verify file exists
             if not os.path.exists(file_path):
+                return (
+                    f"❌ Audio file not found at: {file_path}. Download the file first."
+                )
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Convert to WAV if not already (needed for speech_recognition)
             file_ext = os.path.splitext(file_path)[1].lower()
+            if file_ext != ".wav":
                 # Create temp WAV file
+                temp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
                 # Convert to WAV using pydub
                 audio = AudioSegment.from_file(file_path)
                 audio.export(temp_wav, format="wav")
                 audio_path = temp_wav
             else:
                 audio_path = file_path
             # Transcribe audio using Google's speech recognition
             with sr.AudioFile(audio_path) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file if created
+            if file_ext != ".wav" and os.path.exists(temp_wav):
                 os.remove(temp_wav)
             return transcript.strip()
         except Exception as e:
             return f"❌ Transcription failed: {str(e)}"
 class TranscibeVideoFileTool(Tool):
     name = "transcribe_video"
     description = """Extracts and transcribes speech from video files. Converts the audio portion of videos into readable text for analysis or reference."""
     inputs = {
         "file_path": {
             "type": "string",
+            "description": "The full path to the video file that needs to be transcribed.",
         }
     }
     output_type = "string"
         try:
             # Verify file exists
             if not os.path.exists(file_path):
+                return (
+                    f"❌ Video file not found at: {file_path}. Download the file first."
+                )
             import os
             import tempfile
+            import moviepy.editor as mp
+            import speech_recognition as sr
             # Extract audio from video
             video = mp.VideoFileClip(file_path)
             # Create temporary audio file
+            temp_audio = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
             # Extract audio to WAV format (required for speech_recognition)
             video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
             video.close()
             # Initialize recognizer
             recognizer = sr.Recognizer()
             # Transcribe audio
             with sr.AudioFile(temp_audio) as source:
                 audio_data = recognizer.record(source)
                 transcript = recognizer.recognize_google(audio_data)
             # Clean up temp file
             if os.path.exists(temp_audio):
                 os.remove(temp_audio)
             return transcript.strip()
         except Exception as e:
             return f"❌ Video processing failed: {str(e)}"
 class BraveWebSearchTool(Tool):
     name = "web_search"
     description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
     inputs = {
         "query": {
             "type": "string",
+            "description": "A web search query string (e.g., a question or query).",
         }
     }
     output_type = "string"
     def forward(self, query: str) -> str:
         try:
             results_json = self.tool.run(query)
+            results = (
+                json.loads(results_json)
+                if isinstance(results_json, str)
+                else results_json
+            )
             output_parts = []
+            for i, r in enumerate(results[: self.count], start=1):
                 title = html.unescape(r.get("title", "").strip())
                 link = r.get("link", "").strip()
         except Exception as e:
             return f"Search failed: {str(e)}"
 class DescribeImageTool(Tool):
     name = "describe_image"
     description = """Analyzes images and generates detailed text descriptions. Identifies objects, scenes, text, and visual elements within the image to provide context or understanding."""
     inputs = {
         "image_path": {
             "type": "string",
+            "description": "The full path to the image file to describe.",
         }
     }
     output_type = "string"
     def forward(self, image_path: str) -> str:
         import os
         from PIL import Image
+        from transformers import BlipForConditionalGeneration, BlipProcessor
         if not os.path.exists(image_path):
             return f"❌ Image file does not exist: {image_path}"
         try:
+            processor = BlipProcessor.from_pretrained(
+                "Salesforce/blip-image-captioning-base", use_fast=True
+            )
+            model = BlipForConditionalGeneration.from_pretrained(
+                "Salesforce/blip-image-captioning-base"
+            )
             image = Image.open(image_path).convert("RGB")
             inputs = processor(images=image, return_tensors="pt")
         except Exception as e:
             return f"❌ Failed to describe image: {e}"
 class DownloadFileFromLinkTool(Tool):
     name = "download_file_from_link"
     description = "Downloads files from a URL and saves them locally. Supports various formats including PDFs, documents, images, and data files. Returns the local file path for further processing."
     inputs = {
+        "link": {"type": "string", "description": "The URL to download the file from."},
         "file_name": {
             "type": "string",
             "description": "Desired name of the saved file, without extension.",
+            "nullable": True,
+        },
     }
     output_type = "string"
+    SUPPORTED_EXTENSIONS = {
+        ".xlsx",
+        ".pdf",
+        ".txt",
+        ".csv",
+        ".json",
+        ".xml",
+        ".html",
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".mp4",
+        ".mp3",
+        ".wav",
+        ".zip",
+    }
     def forward(self, link: str, file_name: str = "taskfile") -> str:
         print(f"⬇️ Downloading file from: {link}")
             return f"❌ Error: Request failed - {e}"
         if response.status_code != 200:
+            return (
+                f"❌ Error: Unable to fetch file. Status code: {response.status_code}"
+            )
         # Step 1: Try extracting extension from provided filename
         base_name, provided_ext = os.path.splitext(file_name)
             ext = provided_ext
         else:
             # Step 3: Try to infer from Content-Type
+            content_type = (
+                response.headers.get("Content-Type", "").split(";")[0].strip()
+            )
             guessed_ext = mimetypes.guess_extension(content_type or "") or ""
             # Step 4: If mimetype returned .bin or nothing useful, try to fallback to URL
         return file_path
 class DuckDuckGoSearchTool(Tool):
     name = "web_search"
     description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
     inputs = {
         "query": {
             "type": "string",
+            "description": "The search query to run on DuckDuckGo",
         },
     }
     output_type = "string"
     def forward(self, query: str) -> str:
         self._configure()
+        print(
+            f"EXECUTING TOOL: duckduckgo_search(query='{query}', top_results={top_results})"
+        )
         top_results = 5
                     title = res.get("title", "N/A")
                     url = res.get("href", "N/A")
                     snippet = res.get("body", "N/A")
                     output_lines.append(
                         f"Result {idx}:\n"
                         f"Title: {title}\n"
                 print(f"-> Tool Result (DuckDuckGo): {output[:1500]}...")
                 return output
+            except (
+                DuckDuckGoSearchException,
+                TimeoutException,
+                RatelimitException,
+                ConversationLimitException,
+            ) as e:
                 retries += 1
+                print(
+                    f"⚠️ DuckDuckGo Exception (Attempt {retries}/{max_retries}): {type(e).__name__}: {e}"
+                )
                 traceback.print_exc()
                 time.sleep(retry_sleep)
                 return f"Unhandled exception during DuckDuckGo search: {e}"
         return f"❌ Failed to retrieve results after {max_retries} retries."
 huggingface_ef = embedding_functions.HuggingFaceEmbeddingFunction(
+    api_key=os.environ["HF_TOKEN"], model_name="sentence-transformers/all-mpnet-base-v2"
 )
+SUPPORTED_EXTENSIONS = [
+    ".txt",
+    ".md",
+    ".py",
+    ".pdf",
+    ".json",
+    ".jsonl",
+    ".html",
+    ".htm",
+]
 class AddDocumentToVectorStoreTool(Tool):
     name = "add_document_to_vector_store"
                 return f"Unsupported or missing file: {file_path}"
             docs = self._load_file(path)
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500, chunk_overlap=50
+            )
             split_docs = text_splitter.split_documents(docs)
+            client = chromadb.Client(
+                chromadb.config.Settings(
+                    persist_directory="./chroma_store",
+                )
+            )
+            collection = client.get_or_create_collection(
+                name=collection_name,
+                configuration={"embedding_function": huggingface_ef},
+            )
             texts = [doc.page_content for doc in split_docs]
             metadatas = [doc.metadata for doc in split_docs]
             collection.add(
                 documents=texts,
                 metadatas=metadatas,
+                ids=[f"{path.stem}_{i}" for i in range(len(texts))],
             )
             return f"✅ Successfully added {len(texts)} chunks from '{file_path}' to collection '{collection_name}'."
             print(f"❌ Error in add_to_vector_store: {e}")
             traceback.print_exc()
             return f"Error: {e}"
 class QueryVectorStoreTool(Tool):
     name = "query_downloaded_documents"
     description = "Performs semantic searches across your downloaded documents. Use detailed queries to find specific information, concepts, or answers from your collected resources."
         "top_k": {
             "type": "integer",
             "description": "Number of top results to retrieve. Usually between 3 and 30",
+            "nullable": True,
+        },
     }
     output_type = "string"
         print(f"🔎 Querying vector store '{collection_name}' with: '{query}'")
         try:
+            client = chromadb.Client(
+                chromadb.config.Settings(
+                    persist_directory="./chroma_store",
+                )
+            )
             collection = client.get_collection(name=collection_name)
             results = collection.query(
                 doc = results["documents"][0][i]
                 metadata = results["metadatas"][0][i]
                 formatted.append(
+                    f"Result {i+1}:\n" f"Content: {doc}\n" f"Metadata: {metadata}\n"
                 )
             return "\n".join(formatted) or "No relevant documents found."
             traceback.print_exc()
             return f"Error querying vector store: {e}"
 @tool
 def image_question_answering(image_path: str, prompt: str) -> str:
     """
     Analyzes images and answers specific questions about their content. Can identify objects, read text, describe scenes, or interpret visual information based on your questions.
     Args:
         image_path: The path to the image file
         prompt: The question to ask about the image
     Returns:
         A string answer generated by the local Ollama model
     """
     # Send the image and prompt to Ollama's local model
     response = chat(
+        model="llava",  # Assuming your model is named 'lava'
         messages=[
             {
+                "role": "user",
+                "content": prompt,
+                "images": [path],
             },
         ],
+        options={"temperature": 0.2},  # Slight randomness for naturalness
     )
     return response.message.content.strip()
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
+    description = "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
     inputs = {
         "url": {
             "type": "string",
     def forward(self, url: str) -> str:
         try:
             from urllib.parse import urlparse
             import requests
             from bs4 import BeautifulSoup
             from markdownify import markdownify
             from requests.exceptions import RequestException
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(
                 "You must install packages `markdownify`, `requests`, and `beautifulsoup4` to run this tool: for instance run `pip install markdownify requests beautifulsoup4`."
             ) from e
         try:
             # Get the webpage content
             headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
             }
             response = requests.get(url, headers=headers, timeout=20)
             response.raise_for_status()
             # Parse the HTML with BeautifulSoup
+            soup = BeautifulSoup(response.text, "html.parser")
             # Extract domain name for context
             domain = urlparse(url).netloc
             # Remove common clutter elements
             self._remove_clutter(soup)
             # Try to identify and prioritize main content
             main_content = self._extract_main_content(soup)
             if main_content:
                 # Convert the cleaned HTML to markdown
                 markdown_content = markdownify(str(main_content)).strip()
             else:
                 # Fallback to full page content if main content extraction fails
                 markdown_content = markdownify(str(soup)).strip()
             # Post-process the markdown content
             markdown_content = self._clean_markdown(markdown_content)
             # Add source information
             result = f"Content from {domain}:\n\n{markdown_content}"
             return truncate_content(result, 40000)
         except requests.exceptions.Timeout:
             return f"Error fetching the webpage: {str(e)}"
         except Exception as e:
             return f"An unexpected error occurred: {str(e)}"
     def _remove_clutter(self, soup):
         """Remove common elements that clutter web pages."""
         # Common non-content elements to remove
         clutter_selectors = [
+            "header",
+            "footer",
+            "nav",
+            ".nav",
+            ".navigation",
+            ".menu",
+            ".sidebar",
+            ".footer",
+            ".header",
+            "#footer",
+            "#header",
+            "#nav",
+            "#sidebar",
+            ".widget",
+            ".cookie",
+            ".cookies",
+            ".ad",
+            ".ads",
+            ".advertisement",
+            "script",
+            "style",
+            "noscript",
+            "iframe",
+            ".social",
+            ".share",
+            ".comment",
+            ".comments",
+            ".subscription",
+            ".newsletter",
+            '[role="banner"]',
+            '[role="navigation"]',
+            '[role="complementary"]',
         ]
         for selector in clutter_selectors:
             for element in soup.select(selector):
                 element.decompose()
         # Remove hidden elements
+        for hidden in soup.select(
+            '[style*="display: none"], [style*="display:none"], [style*="visibility: hidden"], [style*="visibility:hidden"], [hidden]'
+        ):
             hidden.decompose()
     def _extract_main_content(self, soup):
         """Try to identify and extract the main content of the page."""
         # Priority order for common main content containers
         main_content_selectors = [
+            "main",
+            '[role="main"]',
+            "article",
+            ".content",
+            ".main-content",
+            ".post-content",
+            "#content",
+            "#main",
+            "#main-content",
+            ".article",
+            ".post",
+            ".entry",
+            ".page-content",
+            ".entry-content",
         ]
         # Try to find the main content container
         for selector in main_content_selectors:
             main_content = soup.select(selector)
                 if len(main_content) > 1:
                     return max(main_content, key=lambda x: len(x.get_text()))
                 return main_content[0]
         # If no main content container found, look for the largest text block
+        paragraphs = soup.find_all("p")
         if paragraphs:
             # Find the parent that contains the most paragraphs
             parents = {}
                     if p.parent not in parents:
                         parents[p.parent] = 0
                     parents[p.parent] += 1
             if parents:
                 # Return the parent with the most paragraphs
                 return max(parents.items(), key=lambda x: x[1])[0]
         # Return None if we can't identify main content
         return None
     def _clean_markdown(self, content):
         """Clean up the markdown content."""
         # Normalize whitespace
+        content = re.sub(r"\n{3,}", "\n\n", content)
         # Remove consecutive duplicate links
+        content = re.sub(r"(\[.*?\]\(.*?\))\s*\1+", r"\1", content)
         # Remove very short lines that are likely menu items
+        lines = content.split("\n")
         filtered_lines = []
         # Skip consecutive short lines (likely menus)
         short_line_threshold = 40  # characters
         consecutive_short_lines = 0
         max_consecutive_short_lines = 3
         for line in lines:
             stripped_line = line.strip()
+            if len(
+                stripped_line
+            ) < short_line_threshold and not stripped_line.startswith("#"):
                 consecutive_short_lines += 1
                 if consecutive_short_lines > max_consecutive_short_lines:
                     continue
             else:
                 consecutive_short_lines = 0
             filtered_lines.append(line)
+        content = "\n".join(filtered_lines)
         # Remove duplicate headers
         seen_headers = set()
+        lines = content.split("\n")
         filtered_lines = []
         for line in lines:
+            if line.startswith("#"):
                 header_text = line.strip()
                 if header_text in seen_headers:
                     continue
                 seen_headers.add(header_text)
             filtered_lines.append(line)
+        content = "\n".join(filtered_lines)
         # Remove lines containing common footer patterns
         footer_patterns = [
+            r"^copyright",
+            r"^©",
+            r"^all rights reserved",
+            r"^terms",
+            r"^privacy policy",
+            r"^contact us",
+            r"^follow us",
+            r"^social media",
+            r"^disclaimer",
         ]
+        footer_pattern = "|".join(footer_patterns)
+        lines = content.split("\n")
         filtered_lines = []
         for line in lines:
             if not re.search(footer_pattern, line.lower()):
                 filtered_lines.append(line)
+        content = "\n".join(filtered_lines)
         return content
 class ArxivSearchTool(Tool):
     name = "arxiv_search"
     description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, abstracts, and download links."""
     inputs = {
+        "query": {
+            "type": "string",
+            "description": "A research-related query (e.g., 'AI regulation')",
+        },
+        "from_date": {
+            "type": "string",
+            "description": "Optional search start date in format (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')",
+            "nullable": True,
+        },
+        "to_date": {
+            "type": "string",
+            "description": "Optional search end date in (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')",
+            "nullable": True,
+        },
     }
     output_type = "string"
                 f"Summary      : {p['abstract'][:500]}{'...' if len(p['abstract'])>500 else ''}",
                 f"Entry ID     : {p['entry_link']}",
                 f"Download link: {p['download_link']}",
+                "",
             ]
         return "\n".join(output_lines).strip()
+from typing import Dict, List
 import requests
 from bs4 import BeautifulSoup
 def fetch_and_parse_arxiv(url: str) -> List[Dict[str, str]]:
     """
         # Abstract
         ab = li.find("span", class_="abstract-full")
+        abstract = (
+            ab.get_text(strip=True).replace("Abstract:", "").strip() if ab else ""
+        )
         # Published date
         d = li.find("p", class_="is-size-7")
                     doi = a_tag["href"]
                     break
+        results.append(
+            {
+                "title": title,
+                "authors": authors,
+                "published": published,
+                "abstract": abstract,
+                "entry_link": entry_link,
+                "download_link": (
+                    entry_link.replace("abs", "pdf") if "abs" in entry_link else "N/A"
+                ),
+            }
+        )
     return results
 from urllib.parse import quote_plus
 def build_arxiv_url(
+    query: str, from_date: str = None, to_date: str = None, size: int = 50
 ) -> str:
     """
     Build an arXiv advanced-search URL matching the exact segment order:

tools_beta.py CHANGED Viewed

@@ -1,24 +1,13 @@
 import os
 import re
-import tempfile
-import mimetypes
-import requests
-import pandas as pd
 import fitz  # PyMuPDF
-from urllib.parse import unquote
-from smolagents import Tool
-from smolagents import Tool
 import requests
-import traceback
 from langchain_community.retrievers import BM25Retriever
 from smolagents import Tool
-import math
-import subprocess
-import sys
-import os
-import re
 class DetectVisualElementsTool(Tool):
@@ -28,204 +17,204 @@ class DetectVisualElementsTool(Tool):
     inputs = {
         "image_path": {
             "type": "string",
-            "description": "The full path to the image file to analyze."
         }
     }
     output_type = "string"
     def forward(self, image_path: str) -> list:
         import os
-        from PIL import Image
         import torch
-        import torchvision.transforms as T
         import torchvision.models.detection as models
         label_map = {
-    0: "unlabeled",
-    1: "person",
-    2: "bicycle",
-    3: "car",
-    4: "motorcycle",
-    5: "airplane",
-    6: "bus",
-    7: "train",
-    8: "truck",
-    9: "boat",
-    10: "traffic",
-    11: "fire",
-    12: "street",
-    13: "stop",
-    14: "parking",
-    15: "bench",
-    16: "bird",
-    17: "cat",
-    18: "dog",
-    19: "horse",
-    20: "sheep",
-    21: "cow",
-    22: "elephant",
-    23: "bear",
-    24: "zebra",
-    25: "giraffe",
-    26: "hat",
-    27: "backpack",
-    28: "umbrella",
-    29: "shoe",
-    30: "eye",
-    31: "handbag",
-    32: "tie",
-    33: "suitcase",
-    34: "frisbee",
-    35: "skis",
-    36: "snowboard",
-    37: "sports",
-    38: "kite",
-    39: "baseball",
-    40: "baseball",
-    41: "skateboard",
-    42: "surfboard",
-    43: "tennis",
-    44: "bottle",
-    45: "plate",
-    46: "wine",
-    47: "cup",
-    48: "fork",
-    49: "knife",
-    50: "spoon",
-    51: "bowl",
-    52: "banana",
-    53: "apple",
-    54: "sandwich",
-    55: "orange",
-    56: "broccoli",
-    57: "carrot",
-    58: "hot",
-    59: "pizza",
-    60: "donut",
-    61: "cake",
-    62: "chair",
-    63: "couch",
-    64: "potted",
-    65: "bed",
-    66: "mirror",
-    67: "dining",
-    68: "window",
-    69: "desk",
-    70: "toilet",
-    71: "door",
-    72: "tv",
-    73: "laptop",
-    74: "mouse",
-    75: "remote",
-    76: "keyboard",
-    77: "cell",
-    78: "microwave",
-    79: "oven",
-    80: "toaster",
-    81: "sink",
-    82: "refrigerator",
-    83: "blender",
-    84: "book",
-    85: "clock",
-    86: "vase",
-    87: "scissors",
-    88: "teddy",
-    89: "hair",
-    90: "toothbrush",
-    91: "hair",
-    92: "banner",
-    93: "blanket",
-    94: "branch",
-    95: "bridge",
-    96: "building",
-    97: "bush",
-    98: "cabinet",
-    99: "cage",
-    100: "cardboard",
-    101: "carpet",
-    102: "ceiling",
-    103: "ceiling",
-    104: "cloth",
-    105: "clothes",
-    106: "clouds",
-    107: "counter",
-    108: "cupboard",
-    109: "curtain",
-    110: "desk",
-    111: "dirt",
-    112: "door",
-    113: "fence",
-    114: "floor",
-    115: "floor",
-    116: "floor",
-    117: "floor",
-    118: "floor",
-    119: "flower",
-    120: "fog",
-    121: "food",
-    122: "fruit",
-    123: "furniture",
-    124: "grass",
-    125: "gravel",
-    126: "ground",
-    127: "hill",
-    128: "house",
-    129: "leaves",
-    130: "light",
-    131: "mat",
-    132: "metal",
-    133: "mirror",
-    134: "moss",
-    135: "mountain",
-    136: "mud",
-    137: "napkin",
-    138: "net",
-    139: "paper",
-    140: "pavement",
-    141: "pillow",
-    142: "plant",
-    143: "plastic",
-    144: "platform",
-    145: "playingfield",
-    146: "railing",
-    147: "railroad",
-    148: "river",
-    149: "road",
-    150: "rock",
-    151: "roof",
-    152: "rug",
-    153: "salad",
-    154: "sand",
-    155: "sea",
-    156: "shelf",
-    157: "sky",
-    158: "skyscraper",
-    159: "snow",
-    160: "solid",
-    161: "stairs",
-    162: "stone",
-    163: "straw",
-    164: "structural",
-    165: "table",
-    166: "tent",
-    167: "textile",
-    168: "towel",
-    169: "tree",
-    170: "vegetable",
-    171: "wall",
-    172: "wall",
-    173: "wall",
-    174: "wall",
-    175: "wall",
-    176: "wall",
-    177: "wall",
-    178: "water",
-    179: "waterdrops",
-    180: "window",
-    181: "window",
-    182: "wood"
-}
         if not os.path.exists(image_path):
             return [f"❌ Image file does not exist: {image_path}"]
@@ -246,7 +235,7 @@ class DetectVisualElementsTool(Tool):
                 if score > 0.8:
                     print(str(label_id.item()))
                     labels_list.append(label_map.get(label_id.item()))
             labels = ",".join(labels_list)
             return labels or ["⚠️ No confident visual elements detected."]
@@ -263,19 +252,17 @@ class ChessPositionSolverTool(Tool):
         "url": {
             "type": "string",
             "description": "Optional. URL pointing to an image of a chessboard position.",
-            "nullable": True
         },
         "file_path": {
             "type": "string",
             "description": "Optional. Local file path to an image of a chessboard position.",
-            "nullable": True
-        }
     }
     output_type = "string"
     def forward(self, url: str = None, file_path: str = None) -> str:
         if not url and not file_path:
             return "❌ Please provide either a URL or a local file path to the chessboard image."
@@ -303,7 +290,10 @@ class ChessPositionSolverTool(Tool):
             board = chess.Board(fen)
-            STOCKFISH_PATH = os.getenv("STOCKFISH_PATH", "/home/boom/Desktop/repos/boombot/engines/stockfish-ubuntu-x86-64-bmi2")  # Ensure Stockfish is available
             # Step 3 - Analyze with Stockfish
             engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
@@ -327,17 +317,19 @@ def patch_pyproject(path):
     with open(pyproject_path, "w", encoding="utf-8") as f:
         for line in lines:
-            if re.match(r'\s*python\s*=', line):
                 f.write('python = ">=3.8,<3.12"\n')
             else:
                 f.write(line)
 def install_chesscog():
     TARGET_DIR = "chesscog"
     REPO_URL = "https://github.com/georg-wolflein/chesscog.git"
     try:
-        import chesscog
         print("✅ chesscog already installed.")
         # return
     except ImportError:
@@ -348,9 +340,12 @@ def install_chesscog():
     patch_pyproject(TARGET_DIR)
-    subprocess.run([sys.executable, "-m", "pip", "install", f"./{TARGET_DIR}"], check=True)
     print("✅ chesscog installed successfully.")
 class RetrieverTool(Tool):
     name = "retriever"
     description = "Retrieves the most similar known question to the query."
@@ -374,6 +369,7 @@ class RetrieverTool(Tool):
         else:
             return "No similar question found."
 class CalculatorTool(Tool):
     name = "calculator"
     description = """Performs basic mathematical calculations (e.g., addition, subtraction, multiplication, division, exponentiation, square root).
@@ -382,7 +378,7 @@ Use this tool whenever math is required, especially for numeric reasoning."""
     inputs = {
         "expression": {
             "type": "string",
-            "description": "A basic math expression, e.g., '5 + 3 * 2', 'sqrt(49)', '2 ** 3'. No variables or natural language."
         }
     }
     output_type = "string"
@@ -390,8 +386,7 @@ Use this tool whenever math is required, especially for numeric reasoning."""
     def forward(self, expression: str) -> str:
         try:
             allowed_names = {
-                k: v for k, v in math.__dict__.items()
-                if not k.startswith("__")
             }
             allowed_names.update({"abs": abs, "round": round})
             result = eval(expression, {"__builtins__": {}}, allowed_names)
@@ -399,6 +394,7 @@ Use this tool whenever math is required, especially for numeric reasoning."""
         except Exception as e:
             return f"Error: Invalid math expression. ({e})"
 class AnalyzeChessImageTool(Tool):
     name = "analyze_chess_image"
     description = """Extracts the board state from a chessboard image and returns the best move for black (in algebraic notation)."""
@@ -406,7 +402,7 @@ class AnalyzeChessImageTool(Tool):
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "Path to the image file of the chess board."
         }
     }
     output_type = "string"
@@ -431,7 +427,6 @@ class AnalyzeChessImageTool(Tool):
             return f"❌ Chess analysis failed: {e}"
 class ExecutePythonCodeTool(Tool):
     name = "execute_python_code"
     description = """Executes a provided Python code snippet in a controlled, sandboxed environment.
@@ -440,7 +435,7 @@ class ExecutePythonCodeTool(Tool):
     inputs = {
         "code": {
             "type": "string",
-            "description": "A valid Python code block that needs to be executed. It should be a string containing executable Python code."
         }
     }
     output_type = "string"
@@ -485,8 +480,8 @@ class ExecutePythonCodeTool(Tool):
             exec(code, restricted_globals, exec_locals)
             # If the code produces a result, we return that as output
-            if 'result' in exec_locals:
-                return str(exec_locals['result'])
             else:
                 return "❌ The code did not produce a result."
@@ -494,7 +489,6 @@ class ExecutePythonCodeTool(Tool):
             return f"❌ Error executing code: {str(e)}"
 class ArxivSearchTool(Tool):
     name = "arxiv_search"
     description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, and abstracts. Ideal for finding scientific research on specific topics."""
@@ -502,7 +496,7 @@ class ArxivSearchTool(Tool):
     inputs = {
         "query": {
             "type": "string",
-            "description": "A research-related query string (e.g., 'Superstring Cosmology')"
         }
     }
     output_type = "string"
@@ -512,9 +506,7 @@ class ArxivSearchTool(Tool):
         try:
             search_docs = ArxivLoader(
-                query=query,
-                load_max_docs=max_results,
-                load_all_available_meta=True
             ).load()
         except Exception as e:
             return f"❌ Arxiv search failed: {e}"
@@ -539,7 +531,9 @@ class ArxivSearchTool(Tool):
             # output_lines.append(f"Journal Ref  : {meta.get('journal_ref', '[N/A]')}")
             # output_lines.append(f"Primary Cat. : {meta.get('primary_category', '[N/A]')}")
             # output_lines.append(f"Categories   : {', '.join(meta.get('categories', [])) or '[N/A]'}")
-            output_lines.append(f"Links        : {', '.join(meta.get('links', [])) or '[N/A]'}")
             if content:
                 preview = content[:30] + ("..." if len(content) > 30 else "")
@@ -547,4 +541,4 @@ class ArxivSearchTool(Tool):
             output_lines.append("")  # spacing between results
-        return "\n".join(output_lines).strip()

+import math
 import os
 import re
+import subprocess
+import sys
 import fitz  # PyMuPDF
 import requests
 from langchain_community.retrievers import BM25Retriever
 from smolagents import Tool
 class DetectVisualElementsTool(Tool):
     inputs = {
         "image_path": {
             "type": "string",
+            "description": "The full path to the image file to analyze.",
         }
     }
     output_type = "string"
     def forward(self, image_path: str) -> list:
         import os
         import torch
         import torchvision.models.detection as models
+        import torchvision.transforms as T
+        from PIL import Image
         label_map = {
+            0: "unlabeled",
+            1: "person",
+            2: "bicycle",
+            3: "car",
+            4: "motorcycle",
+            5: "airplane",
+            6: "bus",
+            7: "train",
+            8: "truck",
+            9: "boat",
+            10: "traffic",
+            11: "fire",
+            12: "street",
+            13: "stop",
+            14: "parking",
+            15: "bench",
+            16: "bird",
+            17: "cat",
+            18: "dog",
+            19: "horse",
+            20: "sheep",
+            21: "cow",
+            22: "elephant",
+            23: "bear",
+            24: "zebra",
+            25: "giraffe",
+            26: "hat",
+            27: "backpack",
+            28: "umbrella",
+            29: "shoe",
+            30: "eye",
+            31: "handbag",
+            32: "tie",
+            33: "suitcase",
+            34: "frisbee",
+            35: "skis",
+            36: "snowboard",
+            37: "sports",
+            38: "kite",
+            39: "baseball",
+            40: "baseball",
+            41: "skateboard",
+            42: "surfboard",
+            43: "tennis",
+            44: "bottle",
+            45: "plate",
+            46: "wine",
+            47: "cup",
+            48: "fork",
+            49: "knife",
+            50: "spoon",
+            51: "bowl",
+            52: "banana",
+            53: "apple",
+            54: "sandwich",
+            55: "orange",
+            56: "broccoli",
+            57: "carrot",
+            58: "hot",
+            59: "pizza",
+            60: "donut",
+            61: "cake",
+            62: "chair",
+            63: "couch",
+            64: "potted",
+            65: "bed",
+            66: "mirror",
+            67: "dining",
+            68: "window",
+            69: "desk",
+            70: "toilet",
+            71: "door",
+            72: "tv",
+            73: "laptop",
+            74: "mouse",
+            75: "remote",
+            76: "keyboard",
+            77: "cell",
+            78: "microwave",
+            79: "oven",
+            80: "toaster",
+            81: "sink",
+            82: "refrigerator",
+            83: "blender",
+            84: "book",
+            85: "clock",
+            86: "vase",
+            87: "scissors",
+            88: "teddy",
+            89: "hair",
+            90: "toothbrush",
+            91: "hair",
+            92: "banner",
+            93: "blanket",
+            94: "branch",
+            95: "bridge",
+            96: "building",
+            97: "bush",
+            98: "cabinet",
+            99: "cage",
+            100: "cardboard",
+            101: "carpet",
+            102: "ceiling",
+            103: "ceiling",
+            104: "cloth",
+            105: "clothes",
+            106: "clouds",
+            107: "counter",
+            108: "cupboard",
+            109: "curtain",
+            110: "desk",
+            111: "dirt",
+            112: "door",
+            113: "fence",
+            114: "floor",
+            115: "floor",
+            116: "floor",
+            117: "floor",
+            118: "floor",
+            119: "flower",
+            120: "fog",
+            121: "food",
+            122: "fruit",
+            123: "furniture",
+            124: "grass",
+            125: "gravel",
+            126: "ground",
+            127: "hill",
+            128: "house",
+            129: "leaves",
+            130: "light",
+            131: "mat",
+            132: "metal",
+            133: "mirror",
+            134: "moss",
+            135: "mountain",
+            136: "mud",
+            137: "napkin",
+            138: "net",
+            139: "paper",
+            140: "pavement",
+            141: "pillow",
+            142: "plant",
+            143: "plastic",
+            144: "platform",
+            145: "playingfield",
+            146: "railing",
+            147: "railroad",
+            148: "river",
+            149: "road",
+            150: "rock",
+            151: "roof",
+            152: "rug",
+            153: "salad",
+            154: "sand",
+            155: "sea",
+            156: "shelf",
+            157: "sky",
+            158: "skyscraper",
+            159: "snow",
+            160: "solid",
+            161: "stairs",
+            162: "stone",
+            163: "straw",
+            164: "structural",
+            165: "table",
+            166: "tent",
+            167: "textile",
+            168: "towel",
+            169: "tree",
+            170: "vegetable",
+            171: "wall",
+            172: "wall",
+            173: "wall",
+            174: "wall",
+            175: "wall",
+            176: "wall",
+            177: "wall",
+            178: "water",
+            179: "waterdrops",
+            180: "window",
+            181: "window",
+            182: "wood",
+        }
         if not os.path.exists(image_path):
             return [f"❌ Image file does not exist: {image_path}"]
                 if score > 0.8:
                     print(str(label_id.item()))
                     labels_list.append(label_map.get(label_id.item()))
             labels = ",".join(labels_list)
             return labels or ["⚠️ No confident visual elements detected."]
         "url": {
             "type": "string",
             "description": "Optional. URL pointing to an image of a chessboard position.",
+            "nullable": True,
         },
         "file_path": {
             "type": "string",
             "description": "Optional. Local file path to an image of a chessboard position.",
+            "nullable": True,
+        },
     }
     output_type = "string"
     def forward(self, url: str = None, file_path: str = None) -> str:
         if not url and not file_path:
             return "❌ Please provide either a URL or a local file path to the chessboard image."
             board = chess.Board(fen)
+            STOCKFISH_PATH = os.getenv(
+                "STOCKFISH_PATH",
+                "/home/boom/Desktop/repos/boombot/engines/stockfish-ubuntu-x86-64-bmi2",
+            )  # Ensure Stockfish is available
             # Step 3 - Analyze with Stockfish
             engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
     with open(pyproject_path, "w", encoding="utf-8") as f:
         for line in lines:
+            if re.match(r"\s*python\s*=", line):
                 f.write('python = ">=3.8,<3.12"\n')
             else:
                 f.write(line)
 def install_chesscog():
     TARGET_DIR = "chesscog"
     REPO_URL = "https://github.com/georg-wolflein/chesscog.git"
     try:
+        pass
         print("✅ chesscog already installed.")
         # return
     except ImportError:
     patch_pyproject(TARGET_DIR)
+    subprocess.run(
+        [sys.executable, "-m", "pip", "install", f"./{TARGET_DIR}"], check=True
+    )
     print("✅ chesscog installed successfully.")
 class RetrieverTool(Tool):
     name = "retriever"
     description = "Retrieves the most similar known question to the query."
         else:
             return "No similar question found."
 class CalculatorTool(Tool):
     name = "calculator"
     description = """Performs basic mathematical calculations (e.g., addition, subtraction, multiplication, division, exponentiation, square root).
     inputs = {
         "expression": {
             "type": "string",
+            "description": "A basic math expression, e.g., '5 + 3 * 2', 'sqrt(49)', '2 ** 3'. No variables or natural language.",
         }
     }
     output_type = "string"
     def forward(self, expression: str) -> str:
         try:
             allowed_names = {
+                k: v for k, v in math.__dict__.items() if not k.startswith("__")
             }
             allowed_names.update({"abs": abs, "round": round})
             result = eval(expression, {"__builtins__": {}}, allowed_names)
         except Exception as e:
             return f"Error: Invalid math expression. ({e})"
 class AnalyzeChessImageTool(Tool):
     name = "analyze_chess_image"
     description = """Extracts the board state from a chessboard image and returns the best move for black (in algebraic notation)."""
     inputs = {
         "file_path": {
             "type": "string",
+            "description": "Path to the image file of the chess board.",
         }
     }
     output_type = "string"
             return f"❌ Chess analysis failed: {e}"
 class ExecutePythonCodeTool(Tool):
     name = "execute_python_code"
     description = """Executes a provided Python code snippet in a controlled, sandboxed environment.
     inputs = {
         "code": {
             "type": "string",
+            "description": "A valid Python code block that needs to be executed. It should be a string containing executable Python code.",
         }
     }
     output_type = "string"
             exec(code, restricted_globals, exec_locals)
             # If the code produces a result, we return that as output
+            if "result" in exec_locals:
+                return str(exec_locals["result"])
             else:
                 return "❌ The code did not produce a result."
             return f"❌ Error executing code: {str(e)}"
 class ArxivSearchTool(Tool):
     name = "arxiv_search"
     description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, and abstracts. Ideal for finding scientific research on specific topics."""
     inputs = {
         "query": {
             "type": "string",
+            "description": "A research-related query string (e.g., 'Superstring Cosmology')",
         }
     }
     output_type = "string"
         try:
             search_docs = ArxivLoader(
+                query=query, load_max_docs=max_results, load_all_available_meta=True
             ).load()
         except Exception as e:
             return f"❌ Arxiv search failed: {e}"
             # output_lines.append(f"Journal Ref  : {meta.get('journal_ref', '[N/A]')}")
             # output_lines.append(f"Primary Cat. : {meta.get('primary_category', '[N/A]')}")
             # output_lines.append(f"Categories   : {', '.join(meta.get('categories', [])) or '[N/A]'}")
+            output_lines.append(
+                f"Links        : {', '.join(meta.get('links', [])) or '[N/A]'}"
+            )
             if content:
                 preview = content[:30] + ("..." if len(content) > 30 else "")
             output_lines.append("")  # spacing between results
+        return "\n".join(output_lines).strip()

utils.py CHANGED Viewed

@@ -1,5 +1,6 @@
 import re
 def extract_final_answer(output: str) -> str:
     """
     Extracts the text after 'FINAL ANSWER:' in the model's output.
@@ -9,27 +10,27 @@ def extract_final_answer(output: str) -> str:
     output = str(output)
     marker = "FINAL ANSWER:"
     lower_output = output.lower()
     if marker.lower() in lower_output:
         # Find actual case version in original output (for safety)
         idx = lower_output.rfind(marker.lower())
-        raw_answer = output[idx + len(marker):].strip()
         # Normalize comma-separated lists: ensure single space after commas
-        cleaned_answer = re.sub(r',\s*', ', ', raw_answer)
         return cleaned_answer
     return output
 def replace_tool_mentions(prompt: str) -> str:
     # Replace tool mentions in backticks: `search` -> `web_search`, `wiki` -> `wikipedia_search`
-    prompt = re.sub(r'(?<!\w)`search`(?!\w)', '`web_search`', prompt)
-    prompt = re.sub(r'(?<!\w)`wiki`(?!\w)', '`wikipedia_search`', prompt)
     # Replace function calls: search(...) -> web_search(...), wiki(...) -> wikipedia_search(...)
     # This ensures we only catch function calls (not words like arxiv_search)
-    prompt = re.sub(r'(?<!\w)(?<!_)search\(', 'web_search(', prompt)
-    prompt = re.sub(r'(?<!\w)(?<!_)wiki\(', 'wikipedia_search(', prompt)
-    return prompt

 import re
 def extract_final_answer(output: str) -> str:
     """
     Extracts the text after 'FINAL ANSWER:' in the model's output.
     output = str(output)
     marker = "FINAL ANSWER:"
     lower_output = output.lower()
     if marker.lower() in lower_output:
         # Find actual case version in original output (for safety)
         idx = lower_output.rfind(marker.lower())
+        raw_answer = output[idx + len(marker) :].strip()
         # Normalize comma-separated lists: ensure single space after commas
+        cleaned_answer = re.sub(r",\s*", ", ", raw_answer)
         return cleaned_answer
     return output
 def replace_tool_mentions(prompt: str) -> str:
     # Replace tool mentions in backticks: `search` -> `web_search`, `wiki` -> `wikipedia_search`
+    prompt = re.sub(r"(?<!\w)`search`(?!\w)", "`web_search`", prompt)
+    prompt = re.sub(r"(?<!\w)`wiki`(?!\w)", "`wikipedia_search`", prompt)
     # Replace function calls: search(...) -> web_search(...), wiki(...) -> wikipedia_search(...)
     # This ensures we only catch function calls (not words like arxiv_search)
+    prompt = re.sub(r"(?<!\w)(?<!_)search\(", "web_search(", prompt)
+    prompt = re.sub(r"(?<!\w)(?<!_)wiki\(", "wikipedia_search(", prompt)
+    return prompt