PraisonAI 0.0.16__tar.gz → 0.0.18__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonAI
-Version: 0.0.16
+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.16 → 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.16 → praisonai-0.0.18}/praisonai/deploy.py

@@ -8,6 +8,32 @@ class CloudDeployer:
         load_dotenv()
         self.set_environment_variables()
 
+    def create_dockerfile(self):
+        with open("Dockerfile", "w") as file:
+            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.18 gunicorn markdown\n")
+            file.write("EXPOSE 8080\n")
+            file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
+            
+    def create_api_file(self):
+        with open("api.py", "w") as file:
+            file.write("from flask import Flask\n")
+            file.write("from praisonai import PraisonAI\n")
+            file.write("import markdown\n\n")
+            file.write("app = Flask(__name__)\n\n")
+            file.write("def basic():\n")
+            file.write("    praison_ai = PraisonAI(agent_file=\"agents.yaml\")\n")
+            file.write("    return praison_ai.main()\n\n")
+            file.write("@app.route('/')\n")
+            file.write("def home():\n")
+            file.write("    output = basic()\n")
+            file.write("    html_output = markdown.markdown(output)\n")
+            file.write("    return f'<html><body>{html_output}</body></html>'\n\n")
+            file.write("if __name__ == \"__main__\":\n")
+            file.write("    app.run(debug=True)\n")
+    
     def set_environment_variables(self):
         """Sets environment variables with fallback to .env values or defaults."""
         os.environ["OPENAI_MODEL_NAME"] = os.getenv("OPENAI_MODEL_NAME", "gpt-4-turbo-preview")
@@ -15,6 +41,8 @@ class CloudDeployer:
         os.environ["OPENAI_API_BASE"] = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
 
     def run_commands(self):
+        self.create_api_file()
+        self.create_dockerfile()
         """Runs a sequence of shell commands for deployment, continues on error."""
         commands = [
             "yes | gcloud auth configure-docker us-central1-docker.pkg.dev",

praisonai-0.0.18/praisonai/tools/__init__.py

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