PraisonAI 0.0.17__tar.gz → 0.0.19__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonAI
-Version: 0.0.17
+Version: 0.0.19
 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,11 +8,12 @@ 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: praisonai-tools (>=0.0.4)
 Requires-Dist: pyautogen (>=0.2.19)
 Requires-Dist: rich (>=13.7)
 Project-URL: Homepage, https://github.com/mervinpraison/praisonAI

praisonai-0.0.19/praisonai/agents_generator.py

@@ -0,0 +1,182 @@
+# praisonai/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 (
+    CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool,
+    FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool,
+    ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, YoutubeChannelSearchTool,
+    YoutubeVideoSearchTool
+)
+from .inbuilt_tools import *
+import inspect
+from pathlib import Path
+import importlib
+import importlib.util
+from praisonai_tools import BaseTool
+
+class AgentsGenerator:
+    def __init__(self, agent_file, framework, config_list):
+        self.agent_file = agent_file
+        self.framework = framework
+        self.config_list = config_list
+        
+    def is_function_or_decorated(self, obj):
+        return inspect.isfunction(obj) or hasattr(obj, '__call__')
+
+    def load_tools_from_module(self, module_path):
+        spec = importlib.util.spec_from_file_location("tools_module", module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        return {name: obj for name, obj in inspect.getmembers(module, self.is_function_or_decorated)}
+    
+    def load_tools_from_module_class(self, module_path):
+        spec = importlib.util.spec_from_file_location("tools_module", module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        return {name: obj() for name, obj in inspect.getmembers(module, lambda x: inspect.isclass(x) and issubclass(x, BaseTool) and x is not BaseTool)}
+
+    def load_tools_from_package(self, package_path):
+        tools_dict = {}
+        for module_file in os.listdir(package_path):
+            if module_file.endswith('.py') and not module_file.startswith('__'):
+                module_name = f"{package_path.name}.{module_file[:-3]}"  # Remove .py for import
+                module = importlib.import_module(module_name)
+                for name, obj in inspect.getmembers(module, self.is_function_or_decorated):
+                    tools_dict[name] = obj
+        return tools_dict
+
+    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(),
+        }
+        root_directory = os.getcwd()
+        tools_py_path = os.path.join(root_directory, 'tools.py')
+        tools_dir_path = Path(root_directory) / 'tools'
+        
+        if os.path.isfile(tools_py_path):
+            tools_dict.update(self.load_tools_from_module_class(tools_py_path))
+            # print("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
+        elif tools_dir_path.is_dir():
+            tools_dict.update(self.load_tools_from_module_class(tools_dir_path))
+            # print("tools folder exists in the root directory")
+        
+        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:
+                        try:
+                            tool_class = globals()[f'autogen_{type(tools_dict[tool]).__name__}']
+                            print(f"Found {tool_class.__name__} for {tool}")
+                        except KeyError:
+                            print(f"Warning: autogen_{type(tools_dict[tool]).__name__} function not found. Skipping this tool.")
+                            continue
+                        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)
+            crew = Crew(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=2
+            )
+
+            response = crew.kickoff()
+            result = f"### Task Output ###\n{response}"
+        return result

{praisonai-0.0.17 → praisonai-0.0.19}/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.19/praisonai/cli.py

@@ -0,0 +1,119 @@
+# 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 .inbuilt_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.startswith("tests.test"): # Argument used for testing purposes
+                print("test")
+            else:
+                self.agent_file = args.agent_file
+        
+        
+        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"], 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()

{praisonai-0.0.17 → praisonai-0.0.19}/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.19 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai-0.0.19/praisonai/inbuilt_tools/__init__.py

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

praisonai-0.0.19/praisonai/inbuilt_tools/autogen_tools.py

@@ -0,0 +1,201 @@
+# praisonai/inbuilt_tools/autogen_tools.py
+
+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
+import os
+import importlib
+from pathlib import Path
+import os
+import inspect
+
+def create_autogen_tool_function(tool_name):
+    def autogen_tool(assistant, user_proxy):
+        def register_tool(tool_class, tool_name, tool_description, assistant, user_proxy):
+            def tool_func(query: str) -> Any:
+                tool_instance = tool_class()
+                return tool_instance.run(query=query)
+            register_function(tool_func, caller=assistant, executor=user_proxy, name=tool_name, description=tool_description)
+
+        root_directory = os.getcwd()
+        tools_py_path = os.path.join(root_directory, 'tools.py')
+        tools_dir_path = Path(root_directory) / 'tools'
+
+        if os.path.isfile(tools_py_path):
+            print(f"{tools_py_path} exists in the root directory. Loading {tools_py_path} and skipping tools folder.")
+            tool_module = importlib.import_module("tools")
+        elif tools_dir_path.is_dir():
+            print(f"tools folder exists in the root directory. Loading {tool_name} from tools/{tool_name}.py.")
+            tool_module = importlib.import_module(f"tools.{tool_name}")
+        else:
+            raise ImportError("Neither tools.py nor tools directory found in the root directory.")
+
+        Tool = getattr(tool_module, tool_name)
+
+        register_tool(Tool, tool_name, f"Description for {tool_name}", assistant, user_proxy)
+
+    return autogen_tool
+
+# Load tools.py
+root_directory = os.getcwd()
+tools_py_path = os.path.join(root_directory, 'tools.py')
+tools_dir_path = Path(root_directory) / 'tools'
+
+tools_module = None
+
+if os.path.isfile(tools_py_path):
+    print(f"{tools_py_path} exists in the root directory. Loading {tools_py_path} and skipping tools folder.")
+    tools_module = importlib.import_module("tools")
+elif tools_dir_path.is_dir():
+    print(f"tools folder exists in the root directory. Loading {tool_name} from tools/{tool_name}.py.")
+    tools_module = importlib.import_module(f"tools.{tool_name}")
+
+# Create autogen_TOOL_NAME_HERE function for each tool
+if tools_module is not None:
+    for name, obj in inspect.getmembers(tools_module):
+        if inspect.isclass(obj):
+            globals()[f"autogen_{name}"] = create_autogen_tool_function(name)
+
+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)

{praisonai-0.0.17 → praisonai-0.0.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "praisonAI"
-version = "0.0.17"
+version = "0.0.19"
 description = "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."
 authors = ["Mervin Praison"]
 license = ""
@@ -21,13 +21,12 @@ crewai = ">=0.22.5"
 gradio = ">=4.20.0"
 Flask = ">=3.0.0"
 markdown = ">=3.5"
+crewai-tools = "^0.1.1"
+praisonai-tools = ">=0.0.4"
 
 [tool.poetry.dev-dependencies]
-pytest = "^5.2"
-pre-commit = "^3.6"
-
-[tool.poetry.extras]
-tools = ["crewai-tools"]
+pytest = "^8.0.0"
+pre-commit = "^3.7"
 
 [build-system]
 requires = ["poetry-core"]

praisonai-0.0.17/praisonai/cli.py

@@ -1,202 +0,0 @@
-# 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
-
-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 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']  
-        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}
-            
-            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.",
-                )
-
-                # 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)
-
-            # Assuming the user proxy agent is set up as per your requirements
-            user = 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
-            )
-            response = user.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)
-                
-                # Assume tools are loaded and handled here as per your requirements
-                agent = Agent(role=role_filled, goal=goal_filled, backstory=backstory_filled, 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)
-
-            crew = Crew(
-                agents=list(agents.values()),
-                tasks=tasks,
-                verbose=2
-            )
-
-            response = crew.kickoff()
-            result = f"### Output ###\n{response}"
-        return result
-
-    def main(self):
-        args = self.parse_args()
-        if args is None:
-            result = self.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.filename = 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.filename = "test.yaml"
-            generator = AutoGenerator(topic=self.topic , framework=self.framework)
-            self.agent_file = generator.generate()
-            result = self.generate_crew_and_kickoff()
-            return result
-        elif args.init or self.init:
-            self.filename = "agents.yaml"
-            generator = AutoGenerator(topic=self.topic , framework=self.framework, filename=self.filename)
-            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:
-            result = self.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()
-            result = self.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()