agno 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/tools/trafilatura.py

@@ -63,6 +63,13 @@ class TrafilaturaTools(Toolkit):
         max_tree_size: Optional[int] = None,
         max_crawl_urls: int = 10,
         max_known_urls: int = 100000,
+        # Tool enable flags for <6 functions
+        enable_extract_text: bool = True,
+        enable_extract_metadata_only: bool = True,
+        enable_html_to_text: bool = True,
+        enable_extract_batch: bool = True,
+        enable_crawl_website: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.output_format = output_format
@@ -80,12 +87,21 @@ class TrafilaturaTools(Toolkit):
         self.max_crawl_urls = max_crawl_urls
         self.max_known_urls = max_known_urls
 
-        tools: List[Callable] = [self.extract_text, self.extract_metadata_only, self.html_to_text, self.extract_batch]
-
-        if not SPIDER_AVAILABLE:
-            logger.warning("Web crawling requested but spider module not available. Skipping crawler tool.")
-        else:
-            tools.append(self.crawl_website)
+        tools: List[Callable] = []
+        if all or enable_extract_text:
+            tools.append(self.extract_text)
+        if all or enable_extract_metadata_only:
+            tools.append(self.extract_metadata_only)
+        if all or enable_html_to_text:
+            tools.append(self.html_to_text)
+        if all or enable_extract_batch:
+            tools.append(self.extract_batch)
+
+        if all or enable_crawl_website:
+            if not SPIDER_AVAILABLE:
+                logger.warning("Web crawling requested but spider module not available. Skipping crawler tool.")
+            else:
+                tools.append(self.crawl_website)
 
         super().__init__(name="trafilatura_tools", tools=tools, **kwargs)
 

agno/tools/trello.py

@@ -17,13 +17,6 @@ class TrelloTools(Toolkit):
         api_key: Optional[str] = None,
         api_secret: Optional[str] = None,
         token: Optional[str] = None,
-        create_card: bool = True,
-        get_board_lists: bool = True,
-        move_card: bool = True,
-        get_cards: bool = True,
-        create_board: bool = True,
-        create_list: bool = True,
-        list_boards: bool = True,
         **kwargs,
     ):
         self.api_key = api_key or getenv("TRELLO_API_KEY")
@@ -39,21 +32,15 @@ class TrelloTools(Toolkit):
             logger.error(f"Error initializing Trello client: {e}")
             self.client = None
 
-        tools: List[Any] = []
-        if create_card:
-            tools.append(self.create_card)
-        if get_board_lists:
-            tools.append(self.get_board_lists)
-        if move_card:
-            tools.append(self.move_card)
-        if get_cards:
-            tools.append(self.get_cards)
-        if create_board:
-            tools.append(self.create_board)
-        if create_list:
-            tools.append(self.create_list)
-        if list_boards:
-            tools.append(self.list_boards)
+        tools: List[Any] = [
+            self.create_card,
+            self.get_board_lists,
+            self.move_card,
+            self.get_cards,
+            self.create_board,
+            self.create_list,
+            self.list_boards,
+        ]
 
         super().__init__(name="trello", tools=tools, **kwargs)
 

agno/tools/twilio.py

@@ -22,6 +22,10 @@ class TwilioTools(Toolkit):
         region: Optional[str] = None,
         edge: Optional[str] = None,
         debug: bool = False,
+        enable_send_sms: bool = True,
+        enable_get_call_details: bool = True,
+        enable_list_messages: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize the Twilio toolkit.
@@ -84,9 +88,12 @@ class TwilioTools(Toolkit):
             self.client.http_client.logger.setLevel(logging.INFO)
 
         tools: List[Any] = []
-        tools.append(self.send_sms)
-        tools.append(self.get_call_details)
-        tools.append(self.list_messages)
+        if all or enable_send_sms:
+            tools.append(self.send_sms)
+        if all or enable_get_call_details:
+            tools.append(self.get_call_details)
+        if all or enable_list_messages:
+            tools.append(self.list_messages)
 
         super().__init__(name="twilio", tools=tools, **kwargs)
 

agno/tools/user_control_flow.py

@@ -9,6 +9,8 @@ class UserControlFlowTools(Toolkit):
         self,
         instructions: Optional[str] = None,
         add_instructions: bool = True,
+        enable_get_user_input: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """A toolkit that provides the ability for the agent to interrupt the agent run and interact with the user."""
@@ -17,7 +19,10 @@ class UserControlFlowTools(Toolkit):
             self.instructions = self.DEFAULT_INSTRUCTIONS
         else:
             self.instructions = instructions
-        tools = [self.get_user_input]
+
+        tools = []
+        if all or enable_get_user_input:
+            tools.append(self.get_user_input)
 
         super().__init__(
             name="user_control_flow_tools",

agno/tools/valyu.py

@@ -12,9 +12,34 @@ except ImportError:
 
 
 class ValyuTools(Toolkit):
+    """
+    Valyu is a toolkit for academic and web search capabilities.
+
+    Args:
+        api_key (Optional[str]): Valyu API key. Retrieved from VALYU_API_KEY env variable if not provided.
+        enable_academic_search (bool): Enable academic sources search functionality. Default is True.
+        enable_web_search (bool): Enable web search functionality. Default is True.
+        enable_paper_search (bool): Enable search within paper functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        text_length (int): Maximum length of text content per result. Default is 1000.
+        max_results (int): Maximum number of results to return. Default is 10.
+        relevance_threshold (float): Minimum relevance score for results. Default is 0.5.
+        content_category (Optional[str]): Content category for filtering.
+        search_start_date (Optional[str]): Start date for search filtering (YYYY-MM-DD).
+        search_end_date (Optional[str]): End date for search filtering (YYYY-MM-DD).
+        search_domains (Optional[List[str]]): List of domains to search within.
+        sources (Optional[List[str]]): List of specific sources to search.
+        max_price (float): Maximum price for API calls. Default is 30.0.
+        tool_call_mode (bool): Enable tool call mode. Default is False.
+    """
+
     def __init__(
         self,
         api_key: Optional[str] = None,
+        enable_academic_search: bool = True,
+        enable_web_search: bool = True,
+        enable_paper_search: bool = True,
+        all: bool = False,
         text_length: int = 1000,
         max_results: int = 10,
         relevance_threshold: float = 0.5,
@@ -43,11 +68,15 @@ class ValyuTools(Toolkit):
         self.sources = sources
         self.tool_call_mode = tool_call_mode
 
-        super().__init__(
-            name="valyu_search",
-            tools=[self.search_academic_sources, self.search_web, self.search_within_paper],
-            **kwargs,
-        )
+        tools: List[Any] = []
+        if all or enable_academic_search:
+            tools.append(self.search_academic_sources)
+        if all or enable_web_search:
+            tools.append(self.search_web)
+        if all or enable_paper_search:
+            tools.append(self.search_within_paper)
+
+        super().__init__(name="valyu_search", tools=tools, **kwargs)
 
     def _parse_results(self, results: List[Any]) -> str:
         parsed_results = []

agno/tools/visualization.py

@@ -9,29 +9,21 @@ from agno.utils.log import log_info, logger
 class VisualizationTools(Toolkit):
     def __init__(
         self,
-        bar_chart: bool = True,
-        line_chart: bool = True,
-        pie_chart: bool = True,
-        scatter_plot: bool = True,
-        histogram: bool = True,
-        enable_all: bool = False,
         output_dir: str = "charts",
+        enable_create_bar_chart: bool = True,
+        enable_create_line_chart: bool = True,
+        enable_create_pie_chart: bool = True,
+        enable_create_scatter_plot: bool = True,
+        enable_create_histogram: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
         Initialize the VisualizationTools toolkit.
 
         Args:
-            bar_chart (bool): Enable bar chart creation. Default is True.
-            line_chart (bool): Enable line chart creation. Default is True.
-            pie_chart (bool): Enable pie chart creation. Default is True.
-            scatter_plot (bool): Enable scatter plot creation. Default is True.
-            histogram (bool): Enable histogram creation. Default is True.
-            enable_all (bool): Enable all chart types. Default is False.
             output_dir (str): Directory to save charts. Default is "charts".
         """
-        super().__init__(**kwargs)
-
         # Check if matplotlib is available
         try:
             import matplotlib
@@ -47,20 +39,19 @@ class VisualizationTools(Toolkit):
 
         self.output_dir = output_dir
 
-        # Register functions based on enabled chart types
-        if enable_all:
-            bar_chart = line_chart = pie_chart = scatter_plot = histogram = True
-
-        if bar_chart:
-            self.register(self.create_bar_chart)
-        if line_chart:
-            self.register(self.create_line_chart)
-        if pie_chart:
-            self.register(self.create_pie_chart)
-        if scatter_plot:
-            self.register(self.create_scatter_plot)
-        if histogram:
-            self.register(self.create_histogram)
+        tools: List[Any] = []
+        if enable_create_bar_chart or all:
+            tools.append(self.create_bar_chart)
+        if enable_create_line_chart or all:
+            tools.append(self.create_line_chart)
+        if enable_create_pie_chart or all:
+            tools.append(self.create_pie_chart)
+        if enable_create_scatter_plot or all:
+            tools.append(self.create_scatter_plot)
+        if enable_create_histogram or all:
+            tools.append(self.create_histogram)
+
+        super().__init__(name="visualization_tools", tools=tools, **kwargs)
 
     def _normalize_data_for_charts(
         self, data: Union[Dict[str, Any], List[Dict[str, Any]], List[Any], str]

agno/tools/webbrowser.py

@@ -7,11 +7,12 @@ from agno.tools import Toolkit
 class WebBrowserTools(Toolkit):
     """Tools for opening a page on the web browser"""
 
-    def __init__(self):
+    def __init__(self, enable_open_page: bool = True, all: bool = False, **kwargs):
         tools: List[Any] = []
-        tools.append(self.open_page)
+        if all or enable_open_page:
+            tools.append(self.open_page)
 
-        super().__init__(name="webbrowser_tools", tools=tools)
+        super().__init__(name="webbrowser_tools", tools=tools, **kwargs)
 
     def open_page(self, url: str, new_window: bool = False):
         """Open a URL in a browser window

agno/tools/webex.py

@@ -1,8 +1,8 @@
 import json
-import os
+from os import getenv
 from typing import Any, List, Optional
 
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
@@ -14,19 +14,23 @@ except ImportError:
 
 class WebexTools(Toolkit):
     def __init__(
-        self, send_message: bool = True, list_rooms: bool = True, access_token: Optional[str] = None, **kwargs
+        self,
+        enable_send_message: bool = True,
+        enable_list_rooms: bool = True,
+        all: bool = False,
+        access_token: Optional[str] = None,
+        **kwargs,
     ):
-        if access_token is None:
-            access_token = os.getenv("WEBEX_ACCESS_TOKEN")
+        access_token = access_token or getenv("WEBEX_ACCESS_TOKEN")
         if access_token is None:
             raise ValueError("Webex access token is not set. Please set the WEBEX_ACCESS_TOKEN environment variable.")
 
         self.client = WebexAPI(access_token=access_token)
 
         tools: List[Any] = []
-        if send_message:
+        if all or enable_send_message:
             tools.append(self.send_message)
-        if list_rooms:
+        if all or enable_list_rooms:
             tools.append(self.list_rooms)
 
         super().__init__(name="webex", tools=tools, **kwargs)

agno/tools/website.py

@@ -1,29 +1,29 @@
 import json
-from typing import Any, List, Optional, Union, cast
+from typing import Any, List, Optional
 
-from agno.document import Document
-from agno.knowledge.combined import CombinedKnowledgeBase
-from agno.knowledge.website import WebsiteKnowledgeBase
+from agno.knowledge.document import Document
+from agno.knowledge.knowledge import Knowledge
 from agno.tools import Toolkit
 from agno.utils.log import log_debug
 
 
 class WebsiteTools(Toolkit):
-    def __init__(self, knowledge_base: Optional[Union[WebsiteKnowledgeBase, CombinedKnowledgeBase]] = None, **kwargs):
-        self.knowledge_base: Optional[Union[WebsiteKnowledgeBase, CombinedKnowledgeBase]] = knowledge_base
+    def __init__(
+        self,
+        knowledge: Optional[Knowledge] = None,
+        **kwargs,
+    ):
+        self.knowledge: Optional[Knowledge] = knowledge
 
         tools: List[Any] = []
-        if self.knowledge_base is not None:
-            if isinstance(self.knowledge_base, WebsiteKnowledgeBase):
-                tools.append(self.add_website_to_knowledge_base)
-            elif isinstance(self.knowledge_base, CombinedKnowledgeBase):
-                tools.append(self.add_website_to_combined_knowledge_base)
+        if self.knowledge is not None:
+            tools.append(self.add_website_to_knowledge)
         else:
             tools.append(self.read_url)
 
         super().__init__(name="website_tools", tools=tools, **kwargs)
 
-    def add_website_to_knowledge_base(self, url: str) -> str:
+    def add_website_to_knowledge(self, url: str) -> str:
         """This function adds a websites content to the knowledge base.
         NOTE: The website must start with https:// and should be a valid website.
 
@@ -32,42 +32,11 @@ class WebsiteTools(Toolkit):
         :param url: The url of the website to add.
         :return: 'Success' if the website was added to the knowledge base.
         """
-        self.knowledge_base = cast(WebsiteKnowledgeBase, self.knowledge_base)
-        if self.knowledge_base is None:
+        if self.knowledge is None:
             return "Knowledge base not provided"
 
         log_debug(f"Adding to knowledge base: {url}")
-        self.knowledge_base.urls.append(url)
-        log_debug("Loading knowledge base.")
-        self.knowledge_base.load(recreate=False)
-        return "Success"
-
-    def add_website_to_combined_knowledge_base(self, url: str) -> str:
-        """This function adds a websites content to the knowledge base.
-        NOTE: The website must start with https:// and should be a valid website.
-
-        USE THIS FUNCTION TO GET INFORMATION ABOUT PRODUCTS FROM THE INTERNET.
-
-        :param url: The url of the website to add.
-        :return: 'Success' if the website was added to the knowledge base.
-        """
-        self.knowledge_base = cast(CombinedKnowledgeBase, self.knowledge_base)
-        if self.knowledge_base is None:
-            return "Knowledge base not provided"
-
-        website_knowledge_base = None
-        for knowledge_base in self.knowledge_base.sources:
-            if isinstance(knowledge_base, WebsiteKnowledgeBase):
-                website_knowledge_base = knowledge_base
-                break
-
-        if website_knowledge_base is None:
-            return "Website knowledge base not found"
-
-        log_debug(f"Adding to knowledge base: {url}")
-        website_knowledge_base.urls.append(url)
-        log_debug("Loading knowledge base.")
-        website_knowledge_base.load(recreate=False)
+        self.knowledge.add_content(url=url)
         return "Success"
 
     def read_url(self, url: str) -> str:
@@ -76,7 +45,7 @@ class WebsiteTools(Toolkit):
         :param url: The url of the website to read.
         :return: Relevant documents from the website.
         """
-        from agno.document.reader.website_reader import WebsiteReader
+        from agno.knowledge.reader.website_reader import WebsiteReader
 
         website = WebsiteReader()
 

agno/tools/webtools.py

@@ -9,12 +9,20 @@ class WebTools(Toolkit):
     A toolkit for working with web-related tools.
     """
 
-    def __init__(self, retries: int = 3):
-        super().__init__(name="web_tools")
-
+    def __init__(
+        self,
+        retries: int = 3,
+        enable_expand_url: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
         self.retries = retries
 
-        self.register(self.expand_url)
+        tools = []
+        if all or enable_expand_url:
+            tools.append(self.expand_url)
+
+        super().__init__(name="web_tools", tools=tools, **kwargs)
 
     def expand_url(self, url: str) -> str:
         """

agno/tools/whatsapp.py

@@ -1,4 +1,4 @@
-import os
+from os import getenv
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -30,25 +30,21 @@ class WhatsAppTools(Toolkit):
             async_mode: Whether to use async methods (default: False)
         """
         # Core credentials
-        self.access_token = access_token or os.getenv("WHATSAPP_ACCESS_TOKEN") or os.getenv("WHATSAPP_ACCESS_TOKEN")
+        self.access_token = access_token or getenv("WHATSAPP_ACCESS_TOKEN")
         if not self.access_token:
             logger.error("WHATSAPP_ACCESS_TOKEN not set. Please set the WHATSAPP_ACCESS_TOKEN environment variable.")
 
-        self.phone_number_id = (
-            phone_number_id or os.getenv("WHATSAPP_PHONE_NUMBER_ID") or os.getenv("WHATSAPP_PHONE_NUMBER_ID")
-        )
+        self.phone_number_id = phone_number_id or getenv("WHATSAPP_PHONE_NUMBER_ID")
         if not self.phone_number_id:
             logger.error(
                 "WHATSAPP_PHONE_NUMBER_ID not set. Please set the WHATSAPP_PHONE_NUMBER_ID environment variable."
             )
 
         # Optional default recipient
-        self.default_recipient = (
-            recipient_waid or os.getenv("WHATSAPP_RECIPIENT_WAID") or os.getenv("WHATSAPP_RECIPIENT_WAID")
-        )
+        self.default_recipient = recipient_waid or getenv("WHATSAPP_RECIPIENT_WAID")
 
         # API version and mode
-        self.version = version or os.getenv("WHATSAPP_VERSION") or os.getenv("WHATSAPP_VERSION", "v22.0")
+        self.version = version or getenv("WHATSAPP_VERSION", "v22.0")
         self.async_mode = async_mode
 
         tools: List[Any] = []

agno/tools/wikipedia.py

@@ -1,18 +1,24 @@
 import json
 from typing import List, Optional
 
-from agno.document import Document
-from agno.knowledge.wikipedia import WikipediaKnowledgeBase
+from agno.knowledge.document import Document
+from agno.knowledge.knowledge import Knowledge
+from agno.knowledge.reader.wikipedia_reader import WikipediaReader
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_info
 
 
 class WikipediaTools(Toolkit):
-    def __init__(self, knowledge_base: Optional[WikipediaKnowledgeBase] = None, **kwargs):
+    def __init__(
+        self,
+        knowledge: Optional[Knowledge] = None,
+        all: bool = False,
+        **kwargs,
+    ):
         tools = []
 
-        self.knowledge_base: Optional[WikipediaKnowledgeBase] = knowledge_base
-        if self.knowledge_base is not None and isinstance(self.knowledge_base, WikipediaKnowledgeBase):
+        self.knowledge: Optional[Knowledge] = knowledge
+        if self.knowledge is not None and isinstance(self.knowledge, Knowledge):
             tools.append(self.search_wikipedia_and_update_knowledge_base)
         else:
             tools.append(self.search_wikipedia)  # type: ignore
@@ -28,15 +34,16 @@ class WikipediaTools(Toolkit):
         :return: Relevant documents from Wikipedia knowledge base.
         """
 
-        if self.knowledge_base is None:
-            return "Knowledge base not provided"
+        if self.knowledge is None:
+            return "Knowledge not provided"
 
-        log_debug(f"Adding to knowledge base: {topic}")
-        self.knowledge_base.topics.append(topic)
-        log_debug("Loading knowledge base.")
-        self.knowledge_base.load(recreate=False)
-        log_debug(f"Searching knowledge base: {topic}")
-        relevant_docs: List[Document] = self.knowledge_base.search(query=topic)
+        log_debug(f"Adding to knowledge: {topic}")
+        self.knowledge.add_content(
+            topics=[topic],
+            reader=WikipediaReader(),
+        )
+        log_debug(f"Searching knowledge: {topic}")
+        relevant_docs: List[Document] = self.knowledge.search(query=topic)
         return json.dumps([doc.to_dict() for doc in relevant_docs])
 
     def search_wikipedia(self, query: str) -> str:

agno/tools/x.py

@@ -1,5 +1,5 @@
 import json
-import os
+from os import getenv
 from typing import Any, List, Optional
 
 from agno.tools import Toolkit
@@ -35,11 +35,11 @@ class XTools(Toolkit):
             include_post_metrics Optional[bool]: Whether to include post metrics in the search results.
             wait_on_rate_limit Optional[bool]: Whether to wait on rate limit.
         """
-        self.bearer_token = bearer_token or os.getenv("X_BEARER_TOKEN")
-        self.consumer_key = consumer_key or os.getenv("X_CONSUMER_KEY")
-        self.consumer_secret = consumer_secret or os.getenv("X_CONSUMER_SECRET")
-        self.access_token = access_token or os.getenv("X_ACCESS_TOKEN")
-        self.access_token_secret = access_token_secret or os.getenv("X_ACCESS_TOKEN_SECRET")
+        self.bearer_token = bearer_token or getenv("X_BEARER_TOKEN")
+        self.consumer_key = consumer_key or getenv("X_CONSUMER_KEY")
+        self.consumer_secret = consumer_secret or getenv("X_CONSUMER_SECRET")
+        self.access_token = access_token or getenv("X_ACCESS_TOKEN")
+        self.access_token_secret = access_token_secret or getenv("X_ACCESS_TOKEN_SECRET")
         self.wait_on_rate_limit = wait_on_rate_limit
         self.client = tweepy.Client(
             bearer_token=self.bearer_token,
@@ -51,13 +51,14 @@ class XTools(Toolkit):
         )
         self.include_post_metrics = include_post_metrics
 
-        tools: List[Any] = []
-        tools.append(self.create_post)
-        tools.append(self.reply_to_post)
-        tools.append(self.send_dm)
-        tools.append(self.get_user_info)
-        tools.append(self.get_home_timeline)
-        tools.append(self.search_posts)
+        tools: List[Any] = [
+            self.create_post,
+            self.reply_to_post,
+            self.send_dm,
+            self.get_user_info,
+            self.get_home_timeline,
+            self.search_posts,
+        ]
 
         super().__init__(name="x", tools=tools, **kwargs)
 

agno/tools/yfinance.py

@@ -1,4 +1,5 @@
 import json
+from typing import Any, List
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug
@@ -12,52 +13,24 @@ except ImportError:
 class YFinanceTools(Toolkit):
     """
     YFinanceTools is a toolkit for getting financial data from Yahoo Finance.
-    Args:
-        stock_price (bool): Whether to get the current stock price.
-        company_info (bool): Whether to get company information.
-        stock_fundamentals (bool): Whether to get stock fundamentals.
-        income_statements (bool): Whether to get income statements.
-        key_financial_ratios (bool): Whether to get key financial ratios.
-        analyst_recommendations (bool): Whether to get analyst recommendations.
-        company_news (bool): Whether to get company news.
-        technical_indicators (bool): Whether to get technical indicators.
-        historical_prices (bool): Whether to get historical prices.
-        enable_all (bool): Whether to enable all tools.
+    Includes all available financial data tools.
     """
 
     def __init__(
         self,
-        stock_price: bool = True,
-        company_info: bool = False,
-        stock_fundamentals: bool = False,
-        income_statements: bool = False,
-        key_financial_ratios: bool = False,
-        analyst_recommendations: bool = False,
-        company_news: bool = False,
-        technical_indicators: bool = False,
-        historical_prices: bool = False,
-        enable_all: bool = False,
         **kwargs,
     ):
-        tools = []
-        if stock_price or enable_all:
-            tools.append(self.get_current_stock_price)
-        if company_info or enable_all:
-            tools.append(self.get_company_info)
-        if stock_fundamentals or enable_all:
-            tools.append(self.get_stock_fundamentals)
-        if income_statements or enable_all:
-            tools.append(self.get_income_statements)
-        if key_financial_ratios or enable_all:
-            tools.append(self.get_key_financial_ratios)
-        if analyst_recommendations or enable_all:
-            tools.append(self.get_analyst_recommendations)
-        if company_news or enable_all:
-            tools.append(self.get_company_news)
-        if technical_indicators or enable_all:
-            tools.append(self.get_technical_indicators)
-        if historical_prices or enable_all:
-            tools.append(self.get_historical_stock_prices)
+        tools: List[Any] = [
+            self.get_current_stock_price,
+            self.get_company_info,
+            self.get_stock_fundamentals,
+            self.get_income_statements,
+            self.get_key_financial_ratios,
+            self.get_analyst_recommendations,
+            self.get_company_news,
+            self.get_technical_indicators,
+            self.get_historical_stock_prices,
+        ]
 
         super().__init__(name="yfinance_tools", tools=tools, **kwargs)