PraisonAI 0.0.17__tar.gz → 0.0.18__tar.gz

{praisonai-0.0.17 → praisonai-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonAI
-Version: 0.0.17
+Version: 0.0.18
 Summary: praisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -8,9 +8,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: tools
 Requires-Dist: Flask (>=3.0.0)
 Requires-Dist: crewai (>=0.22.5)
+Requires-Dist: crewai-tools (>=0.1.1,<0.2.0)
 Requires-Dist: gradio (>=4.20.0)
 Requires-Dist: markdown (>=3.5)
 Requires-Dist: pyautogen (>=0.2.19)

praisonai-0.0.18/praisonai/agents_generator.py

@@ -0,0 +1,221 @@
+# agents_generator.py
+
+import sys
+from .version import __version__
+import yaml, os
+from rich import print
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew
+load_dotenv()
+import autogen
+import gradio as gr
+import argparse
+from .auto import AutoGenerator
+from crewai_tools import *
+from .tools import *
+
+class AgentsGenerator:
+    def __init__(self, agent_file, framework, config_list):
+        self.agent_file = agent_file
+        self.framework = framework
+        self.config_list = config_list
+
+    def generate_crew_and_kickoff(self):
+        if self.agent_file == '/app/api:app' or self.agent_file == 'api:app':
+            self.agent_file = 'agents.yaml'
+        try:
+            with open(self.agent_file, 'r') as f:
+                config = yaml.safe_load(f)
+        except FileNotFoundError:
+            print(f"File not found: {self.agent_file}")
+            return
+
+        topic = config['topic']
+        tools_dict = {
+            'CodeDocsSearchTool': CodeDocsSearchTool(),
+            'CSVSearchTool': CSVSearchTool(),
+            'DirectorySearchTool': DirectorySearchTool(),
+            'DOCXSearchTool': DOCXSearchTool(),
+            'DirectoryReadTool': DirectoryReadTool(),
+            'FileReadTool': FileReadTool(),
+            # 'GithubSearchTool': GithubSearchTool(),
+            # 'SeperDevTool': SeperDevTool(),
+            'TXTSearchTool': TXTSearchTool(),
+            'JSONSearchTool': JSONSearchTool(),
+            'MDXSearchTool': MDXSearchTool(),
+            'PDFSearchTool': PDFSearchTool(),
+            # 'PGSearchTool': PGSearchTool(),
+            'RagTool': RagTool(),
+            'ScrapeElementFromWebsiteTool': ScrapeElementFromWebsiteTool(),
+            'ScrapeWebsiteTool': ScrapeWebsiteTool(),
+            'WebsiteSearchTool': WebsiteSearchTool(),
+            'XMLSearchTool': XMLSearchTool(),
+            'YoutubeChannelSearchTool': YoutubeChannelSearchTool(),
+            'YoutubeVideoSearchTool': YoutubeVideoSearchTool() 
+        }
+        # config['tools'] = [tools_dict[tool] for tool in config.get('tools', []) if tool in tools_dict]
+        framework = self.framework or config.get('framework')
+
+        agents = {}
+        tasks = []
+        if framework == "autogen":
+            # Load the LLM configuration dynamically
+            # print(self.config_list)
+            llm_config = {"config_list": self.config_list}
+            
+            # Assuming the user proxy agent is set up as per your requirements
+            user_proxy = autogen.UserProxyAgent(
+                name="User",
+                human_input_mode="NEVER",
+                is_termination_msg=lambda x: (x.get("content") or "").rstrip().rstrip(".").lower().endswith("terminate") or "TERMINATE" in (x.get("content") or ""),
+                code_execution_config={
+                    "work_dir": "coding",
+                    "use_docker": False,
+                },
+                # additional setup for the user proxy agent
+            )
+            
+            for role, details in config['roles'].items():
+                agent_name = details['role'].format(topic=topic).replace("{topic}", topic)
+                agent_goal = details['goal'].format(topic=topic)
+                # Creating an AssistantAgent for each role dynamically
+                agents[role] = autogen.AssistantAgent(
+                    name=agent_name,
+                    llm_config=llm_config,
+                    system_message=details['backstory'].format(topic=topic)+". Must Reply \"TERMINATE\" in the end when everything is done.",
+                )
+                for tool in details.get('tools', []):
+                    if tool in tools_dict:
+                        tool_class = globals()[f'autogen_{type(tools_dict[tool]).__name__}']
+                        tool_class(agents[role], user_proxy)
+
+                # Preparing tasks for initiate_chats
+                for task_name, task_details in details.get('tasks', {}).items():
+                    description_filled = task_details['description'].format(topic=topic)
+                    expected_output_filled = task_details['expected_output'].format(topic=topic)
+                    
+                    chat_task = {
+                        "recipient": agents[role],
+                        "message": description_filled,
+                        "summary_method": "last_msg", 
+                        # Additional fields like carryover can be added based on dependencies
+                    }
+                    tasks.append(chat_task)
+
+            response = user_proxy.initiate_chats(tasks)
+            result = "### Output ###\n"+response[-1].summary if hasattr(response[-1], 'summary') else ""
+        else:
+            for role, details in config['roles'].items():
+                role_filled = details['role'].format(topic=topic)
+                goal_filled = details['goal'].format(topic=topic)
+                backstory_filled = details['backstory'].format(topic=topic)
+                
+                # Adding tools to the agent if exists
+                agent_tools = [tools_dict[tool] for tool in details.get('tools', []) if tool in tools_dict]
+                agent = Agent(role=role_filled, goal=goal_filled, backstory=backstory_filled, tools=agent_tools, allow_delegation=False)
+                agents[role] = agent
+
+                for task_name, task_details in details.get('tasks', {}).items():
+                    description_filled = task_details['description'].format(topic=topic)
+                    expected_output_filled = task_details['expected_output'].format(topic=topic)
+
+                    task = Task(description=description_filled, expected_output=expected_output_filled, agent=agent)
+                    tasks.append(task)
+            # print(agents)
+            crew = Crew(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=2
+            )
+
+            response = crew.kickoff()
+            result = f"### Task Output ###\n{response}"
+        return result
+    
+
+# # AutoGen Tools example below
+# from typing import Any, Optional
+# import os
+# from autogen import ConversableAgent
+# from autogen_tools import autogen_ScrapeWebsiteTool
+
+# assistant = ConversableAgent(
+#     name="Assistant",
+#     system_message="You are a helpful AI assistant. "
+#     "You can help with website scraping. "
+#     "Return 'TERMINATE' when the task is done.",
+#     llm_config={"config_list": [{"model": "gpt-3.5-turbo", "api_key": os.environ["OPENAI_API_KEY"]}]},
+# )
+
+# user_proxy = ConversableAgent(
+#     name="User",
+#     llm_config=False,
+#     is_termination_msg=lambda msg: msg.get("content") is not None and "TERMINATE" in msg["content"],
+#     human_input_mode="NEVER",
+# )
+
+# autogen_ScrapeWebsiteTool(assistant, user_proxy)
+
+# chat_result = user_proxy.initiate_chat(assistant, message="Scrape the official Nodejs website.")
+
+# # CrewAI Tools example below 
+# import os
+# from crewai import Agent, Task, Crew
+# # Importing crewAI tools
+# from crewai_tools import (
+#     DirectoryReadTool,
+#     FileReadTool,
+#     SerperDevTool,
+#     WebsiteSearchTool
+# )
+
+# # Set up API keys
+# os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+# os.environ["OPENAI_API_KEY"] = "Your Key"
+
+# # Instantiate tools
+# docs_tool = DirectoryReadTool(directory='./blog-posts')
+# file_tool = FileReadTool()
+# search_tool = SerperDevTool()
+# web_rag_tool = WebsiteSearchTool()
+
+# # Create agents
+# researcher = Agent(
+#     role='Market Research Analyst',
+#     goal='Provide up-to-date market analysis of the AI industry',
+#     backstory='An expert analyst with a keen eye for market trends.',
+#     tools=[search_tool, web_rag_tool],
+#     verbose=True
+# )
+
+# writer = Agent(
+#     role='Content Writer',
+#     goal='Craft engaging blog posts about the AI industry',
+#     backstory='A skilled writer with a passion for technology.',
+#     tools=[docs_tool, file_tool],
+#     verbose=True
+# )
+
+# # Define tasks
+# research = Task(
+#     description='Research the latest trends in the AI industry and provide a summary.',
+#     expected_output='A summary of the top 3 trending developments in the AI industry with a unique perspective on their significance.',
+#     agent=researcher
+# )
+
+# write = Task(
+#     description='Write an engaging blog post about the AI industry, based on the research analyst’s summary. Draw inspiration from the latest blog posts in the directory.',
+#     expected_output='A 4-paragraph blog post formatted in markdown with engaging, informative, and accessible content, avoiding complex jargon.',
+#     agent=writer,
+#     output_file='blog-posts/new_post.md'  # The final blog post will be saved here
+# )
+
+# # Assemble a crew
+# crew = Crew(
+#     agents=[researcher, writer],
+#     tasks=[research, write],
+#     verbose=2
+# )
+
+# # Execute tasks
+# crew.kickoff()

{praisonai-0.0.17 → praisonai-0.0.18}/praisonai/auto.py

@@ -1,6 +1,6 @@
 from openai import OpenAI
 from pydantic import BaseModel
-from typing import Dict
+from typing import Dict, List
 import instructor
 import os
 import json
@@ -17,12 +17,13 @@ class RoleDetails(BaseModel):
     goal: str
     backstory: str
     tasks: Dict[str, TaskDetails]
+    tools: List[str]
 
 class TeamStructure(BaseModel):
     roles: Dict[str, RoleDetails]
 
 class AutoGenerator:
-    def __init__(self, topic="Movie Story writing about AI", filename="test.yaml", framework="crewai"):
+    def __init__(self, topic="Movie Story writing about AI", agent_file="test.yaml", framework="crewai"):
         self.config_list = [
             {
                 'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4-turbo-preview"),
@@ -30,7 +31,7 @@ class AutoGenerator:
             }
         ]
         self.topic = topic
-        self.filename = filename
+        self.agent_file = agent_file
         self.framework = framework
         self.client = instructor.patch(
             OpenAI(
@@ -52,7 +53,7 @@ class AutoGenerator:
         )
         json_data = json.loads(response.model_dump_json())
         self.convert_and_save(json_data)
-        full_path = os.path.abspath(self.filename)
+        full_path = os.path.abspath(self.agent_file)
         return full_path
 
     def convert_and_save(self, json_data):
@@ -61,7 +62,7 @@ class AutoGenerator:
         Args:
             json_data (dict): The JSON data representing the team structure.
             topic (str, optional): The topic to be inserted into the YAML. Defaults to "Artificial Intelligence".
-            filename (str, optional): The name of the YAML file to save. Defaults to "test.yaml".
+            agent_file (str, optional): The name of the YAML file to save. Defaults to "test.yaml".
         """
 
         yaml_data = {
@@ -76,7 +77,9 @@ class AutoGenerator:
                 "backstory": "" + role_details['backstory'],
                 "goal": role_details['goal'],
                 "role": role_details['role'],
-                "tasks": {}
+                "tasks": {},
+                # "tools": role_details.get('tools', []),
+                "tools": ['']
             }
 
             for task_id, task_details in role_details['tasks'].items():
@@ -86,7 +89,7 @@ class AutoGenerator:
                 }
 
         # Save to YAML file, maintaining the order
-        with open(self.filename, 'w') as f:
+        with open(self.agent_file, 'w') as f:
             yaml.dump(yaml_data, f, allow_unicode=True, sort_keys=False)
 
     def get_user_content(self):
@@ -96,6 +99,8 @@ The team will work in sequence. First role will pass the output to the next role
 The last role will generate the final output.
 Think step by step.
 With maximum 3 roles, each with 1 task. Include role goals, backstories, task descriptions, and expected outputs.
+List of Available Tools: CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool, FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool, ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, YoutubeChannelSearchTool, YoutubeVideoSearchTool.
+Only use Available Tools. Do Not use any other tools. 
 Example Below: 
 Use below example to understand the structure of the output. 
 The final role you create should satisfy the provided task: """ + self.topic + """.
@@ -105,9 +110,10 @@ The final role you create should satisfy the provided task: """ + self.topic + "
 "role": "Narrative Designer",
 "goal": "Create AI storylines",
 "backstory": "Skilled in narrative development for AI, with a focus on story resonance.",
+"tools": ["ScrapeWebsiteTool"],
 "tasks": {
 "story_concept_development": {
-"description": "Craft a unique AI story concept with depth and engagement.",
+"description": "Craft a unique AI story concept with depth and engagement using concept from this page the content https://www.asthebirdfliesblog.com/posts/how-to-write-book-story-development .",
 "expected_output": "Document with narrative arcs, character bios, and settings."
 }
 }

praisonai-0.0.18/praisonai/cli.py

@@ -0,0 +1,164 @@
+# praisonai/cli.py
+
+import sys
+from .version import __version__
+import yaml, os
+from rich import print
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew
+load_dotenv()
+import autogen
+import gradio as gr
+import argparse
+from .auto import AutoGenerator
+from .agents_generator import AgentsGenerator
+from crewai_tools import *
+from .tools import *
+
+class PraisonAI:
+    def __init__(self, agent_file="agents.yaml", framework="crewai", auto=False, init=False):
+        self.config_list = [
+            {
+                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4-turbo-preview"),
+                'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
+            }
+        ]
+        self.agent_file = agent_file
+        self.framework = framework
+        self.auto = auto
+        self.init = init
+
+    def main(self):
+        args = self.parse_args()
+        if args is None:
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+        if args.deploy:
+            from .deploy import CloudDeployer
+            deployer = CloudDeployer()
+            deployer.run_commands()
+            return
+        invocation_cmd = "praisonai"
+        version_string = f"PraisonAI version {__version__}"
+        
+        if args.framework:
+            self.framework = args.framework
+        
+        ui = args.ui
+
+        if args.agent_file:
+            if args.agent_file == "tests.test": # Argument used for testing purposes
+                full_path = os.path.abspath("agents.yaml")
+            else:
+                full_path = os.path.abspath(args.agent_file)
+            self.agent_file = full_path
+        else:
+            full_path = os.path.abspath(self.agent_file)
+            self.agent_file = full_path
+        
+        if args.auto or args.init:
+            temp_topic = ' '.join(args.auto) if args.auto else ' '.join(args.init)
+            self.topic = temp_topic
+        elif self.auto or self.init:  # Use the auto attribute if args.auto is not provided
+            self.topic = self.auto
+            
+        if args.auto or self.auto:
+            self.agent_file = "test.yaml"
+            generator = AutoGenerator(topic=self.topic , framework=self.framework, agent_file=self.agent_file)
+            self.agent_file = generator.generate()
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+        elif args.init or self.init:
+            self.agent_file = "agents.yaml"
+            generator = AutoGenerator(topic=self.topic , framework=self.framework, agent_file=self.agent_file)
+            self.agent_file = generator.generate()
+            print("File {} created successfully".format(self.agent_file))
+            return "File {} created successfully".format(self.agent_file)
+        
+        if ui:
+            self.create_gradio_interface()
+        else:
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+            
+    def parse_args(self):
+        parser = argparse.ArgumentParser(prog="praisonai", description="praisonAI command-line interface")
+        parser.add_argument("--framework", choices=["crewai", "autogen"], default="crewai", help="Specify the framework")
+        parser.add_argument("--ui", action="store_true", help="Enable UI mode")
+        parser.add_argument("--auto", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
+        parser.add_argument("--init", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
+        parser.add_argument("agent_file", nargs="?", help="Specify the agent file")
+        parser.add_argument("--deploy", action="store_true", help="Deploy the application")  # New argument
+
+        args, unknown_args = parser.parse_known_args()
+
+        if unknown_args and unknown_args[0] == '-b' and unknown_args[1] == 'api:app':
+            args.agent_file = 'agents.yaml'
+        if args.agent_file == 'api:app' or args.agent_file == '/app/api:app':
+            args.agent_file = 'agents.yaml'
+
+        return args
+
+    def create_gradio_interface(self):
+        def generate_crew_and_kickoff_interface(auto_args, framework):
+            self.framework = framework
+            self.agent_file = "test.yaml"
+            generator = AutoGenerator(topic=auto_args , framework=self.framework)
+            self.agent_file = generator.generate()
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+
+        gr.Interface(
+            fn=generate_crew_and_kickoff_interface,
+            inputs=[gr.Textbox(lines=2, label="Auto Args"), gr.Dropdown(choices=["crewai", "autogen"], label="Framework")],
+            outputs="textbox",
+            title="Praison AI Studio",
+            description="Create Agents and perform tasks",
+            theme="default"
+        ).launch()
+
+if __name__ == "__main__":
+    praison_ai = PraisonAI()
+    praison_ai.main()
+
+
+
+## agents.yaml
+# framework: autogen
+# topic: create movie script about cat in mars
+# roles:
+#   concept_developer:
+#     backstory: Experienced in creating captivating and original story concepts.
+#     goal: Generate a unique concept for a movie script about a cat in Mars
+#     role: Concept Developer
+#     tools:
+#     - search_tool
+#     tasks:
+#       concept_generation:
+#         description: Develop a unique and engaging concept for a movie script about
+#           a cat in Mars.
+#         expected_output: A detailed concept document for the movie script.
+#   scriptwriter:
+#     backstory: Expert in dialogue and script structure, translating concepts into
+#       scripts.
+#     goal: Write a script based on the movie concept
+#     role: Scriptwriter
+#     tasks:
+#       scriptwriting_task:
+#         description: Turn the movie concept into a script, including dialogue and
+#           scenes.
+#         expected_output: A production-ready script for the movie about a cat in Mars.
+#   director:
+#     backstory: Experienced in visualizing scripts and creating compelling storyboards.
+#     goal: Create a storyboard and visualize the script
+#     role: Director
+#     tasks:
+#       storyboard_creation:
+#         description: Create a storyboard for the movie script about a cat in Mars.
+#         expected_output: A detailed storyboard for the movie about a cat in Mars.
+# dependencies: []
+

{praisonai-0.0.17 → praisonai-0.0.18}/praisonai/deploy.py

@@ -13,7 +13,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==0.0.17 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==0.0.18 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai-0.0.18/praisonai/tools/__init__.py

@@ -0,0 +1,2 @@
+from .base_tool import BaseTool, Tool, tool
+from .autogen_tools import *

praisonai-0.0.18/praisonai/tools/autogen_tools.py

@@ -0,0 +1,147 @@
+from crewai_tools import (
+    CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool,
+    FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool,
+    ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, YoutubeChannelSearchTool,
+    YoutubeVideoSearchTool
+)
+from typing import Any
+from autogen import register_function
+
+def autogen_CodeDocsSearchTool(assistant, user_proxy):
+    def register_code_docs_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(docs_url: str, search_query: str) -> Any:
+            tool_instance = tool_class(docs_url=docs_url, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_code_docs_search_tool(CodeDocsSearchTool, "code_docs_search_tool", "Search a Code Docs content(search_query: 'string', docs_url: 'string') - A tool that can be used to semantic search a query from a Code Docs content.", assistant, user_proxy)
+
+def autogen_CSVSearchTool(assistant, user_proxy):
+    def register_csv_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(csv: str, search_query: str) -> Any:
+            tool_instance = tool_class(csv=csv, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_csv_search_tool(CSVSearchTool, "csv_search_tool", "Search a CSV's content(search_query: 'string', csv: 'string') - A tool that can be used to semantic search a query from a CSV's content.", assistant, user_proxy)
+
+def autogen_DirectorySearchTool(assistant, user_proxy):
+    def register_directory_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(directory: str, search_query: str) -> Any:
+            tool_instance = tool_class(directory=directory, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_directory_search_tool(DirectorySearchTool, "directory_search_tool", "Search a directory's content(search_query: 'string', directory: 'string') - A tool that can be used to semantic search a query from a directory's content.", assistant, user_proxy)
+
+def autogen_DOCXSearchTool(assistant, user_proxy):
+    def register_docx_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(docx: str, search_query: str) -> Any:
+            tool_instance = tool_class(docx=docx, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_docx_search_tool(DOCXSearchTool, "docx_search_tool", "Search a DOCX's content(search_query: 'string', docx: 'string') - A tool that can be used to semantic search a query from a DOCX's content.", assistant, user_proxy)
+
+# DirectoryReadTool
+def autogen_DirectoryReadTool(assistant, user_proxy):
+    def register_directory_read_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(directory: str) -> Any:
+            tool_instance = tool_class(directory=directory)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_directory_read_tool(DirectoryReadTool, "directory_read_tool", "List files in directory(directory: 'string') - A tool that can be used to recursively list a directory's content.", assistant, user_proxy)
+
+# FileReadTool
+def autogen_FileReadTool(assistant, user_proxy):
+    def register_file_read_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(file_path: str) -> Any:
+            tool_instance = tool_class(file_path=file_path)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_file_read_tool(FileReadTool, "file_read_tool", "Read a file's content(file_path: 'string') - A tool that can be used to read a file's content.", assistant, user_proxy)
+
+# TXTSearchTool
+def autogen_TXTSearchTool(assistant, user_proxy):
+    def register_txt_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(txt: str, search_query: str) -> Any:
+            tool_instance = tool_class(txt=txt, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_txt_search_tool(TXTSearchTool, "txt_search_tool", "Search a txt's content(search_query: 'string', txt: 'string') - A tool that can be used to semantic search a query from a txt's content.", assistant, user_proxy)
+
+def autogen_JSONSearchTool(assistant, user_proxy):
+    def register_json_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(json_path: str, search_query: str) -> Any:
+            tool_instance = tool_class(json_path=json_path, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_json_search_tool(JSONSearchTool, "json_search_tool", "Search a JSON's content(search_query: 'string', json_path: 'string') - A tool that can be used to semantic search a query from a JSON's content.", assistant, user_proxy)
+
+def autogen_MDXSearchTool(assistant, user_proxy):
+    def register_mdx_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(mdx: str, search_query: str) -> Any:
+            tool_instance = tool_class(mdx=mdx, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_mdx_search_tool(MDXSearchTool, "mdx_search_tool", "Search a MDX's content(search_query: 'string', mdx: 'string') - A tool that can be used to semantic search a query from a MDX's content.", assistant, user_proxy)
+
+def autogen_PDFSearchTool(assistant, user_proxy):
+    def register_pdf_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(pdf: str, search_query: str) -> Any:
+            tool_instance = tool_class(pdf=pdf, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_pdf_search_tool(PDFSearchTool, "pdf_search_tool", "Search a PDF's content(search_query: 'string', pdf: 'string') - A tool that can be used to semantic search a query from a PDF's content.", assistant, user_proxy)
+
+def autogen_RagTool(assistant, user_proxy):
+    def register_rag_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(query: str, data: Any) -> Any:
+            tool_instance = tool_class(query=query, data=data)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_rag_tool(RagTool, "rag_tool", "Knowledge base(query: 'string', data: Any) - A knowledge base that can be used to answer questions.", assistant, user_proxy)
+
+def autogen_ScrapeElementFromWebsiteTool(assistant, user_proxy):
+    def register_scrape_element_from_website_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(website_url: str, element_query: str) -> Any:
+            tool_instance = tool_class(website_url=website_url, element_query=element_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_scrape_element_from_website_tool(ScrapeElementFromWebsiteTool, "scrape_element_from_website_tool", "Scrape an element from a website(element_query: 'string', website_url: 'string') - A tool that can be used to scrape an element from a website.", assistant, user_proxy)
+
+def autogen_ScrapeWebsiteTool(assistant, user_proxy):
+    def register_scrape_website_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(website_url: str) -> Any:
+            tool_instance = tool_class(website_url=website_url)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_scrape_website_tool(ScrapeWebsiteTool, "scrape_website_tool", "Read website content(website_url: 'string') - A tool that can be used to read content from a specified website.", assistant, user_proxy)
+
+def autogen_WebsiteSearchTool(assistant, user_proxy):
+    def register_website_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(website: str, search_query: str) -> Any:
+            tool_instance = tool_class(website=website, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_website_search_tool(WebsiteSearchTool, "website_search_tool", "Search in a specific website(search_query: 'string', website: 'string') - A tool that can be used to semantic search a query from a specific URL content.", assistant, user_proxy)
+
+def autogen_XMLSearchTool(assistant, user_proxy):
+    def register_xml_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(xml: str, search_query: str) -> Any:
+            tool_instance = tool_class(xml=xml, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_xml_search_tool(XMLSearchTool, "xml_search_tool", "Search a XML's content(search_query: 'string', xml: 'string') - A tool that can be used to semantic search a query from a XML's content.", assistant, user_proxy)
+
+def autogen_YoutubeChannelSearchTool(assistant, user_proxy):
+    def register_youtube_channel_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(youtube_channel_handle: str, search_query: str) -> Any:
+            tool_instance = tool_class(youtube_channel_handle=youtube_channel_handle, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_youtube_channel_search_tool(YoutubeChannelSearchTool, "youtube_channel_search_tool", "Search a Youtube Channels content(search_query: 'string', youtube_channel_handle: 'string') - A tool that can be used to semantic search a query from a Youtube Channels content.", assistant, user_proxy)
+
+def autogen_YoutubeVideoSearchTool(assistant, user_proxy):
+    def register_youtube_video_search_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+        def tool_func(youtube_video_url: str, search_query: str) -> Any:
+            tool_instance = tool_class(youtube_video_url=youtube_video_url, search_query=search_query)
+            return tool_instance.run()
+        register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+    register_youtube_video_search_tool(YoutubeVideoSearchTool, "youtube_video_search_tool", "Search a Youtube Video content(search_query: 'string', youtube_video_url: 'string') - A tool that can be used to semantic search a query from a Youtube Video content.", assistant, user_proxy)