PraisonAI 0.1.10__cp312-cp312-manylinux_2_35_x86_64.whl → 1.0.0__cp312-cp312-manylinux_2_35_x86_64.whl

praisonai/agents_generator.py

@@ -5,34 +5,55 @@ from .version import __version__
 import yaml, os
 from rich import print
 from dotenv import load_dotenv
-from crewai import Agent, Task, Crew
-from crewai.telemetry import Telemetry
-load_dotenv()
-import autogen
-import argparse
 from .auto import AutoGenerator
-from praisonai_tools import (
-    CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool,
-    FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool,
-    ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, YoutubeChannelSearchTool,
-    YoutubeVideoSearchTool
-)
 from .inbuilt_tools import *
 from .inc import PraisonAIModel
 import inspect
 from pathlib import Path
 import importlib
 import importlib.util
-from praisonai_tools import BaseTool
 import os
 import logging
 
-agentops_exists = False
+# Framework-specific imports with availability checks
+CREWAI_AVAILABLE = False
+AUTOGEN_AVAILABLE = False
+PRAISONAI_TOOLS_AVAILABLE = False
+AGENTOPS_AVAILABLE = False
+
+try:
+    from crewai import Agent, Task, Crew
+    from crewai.telemetry import Telemetry
+    CREWAI_AVAILABLE = True
+except ImportError:
+    pass
+
+try:
+    import autogen
+    AUTOGEN_AVAILABLE = True
+except ImportError:
+    pass
+
 try:
     import agentops
-    agentops_exists = True
+    AGENTOPS_AVAILABLE = True
 except ImportError:
-    agentops_exists = False
+    pass
+
+# Only try to import praisonai_tools if either CrewAI or AutoGen is available
+if CREWAI_AVAILABLE or AUTOGEN_AVAILABLE:
+    try:
+        from praisonai_tools import (
+            CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool,
+            FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool,
+            ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, 
+            YoutubeChannelSearchTool, YoutubeVideoSearchTool, BaseTool
+        )
+        PRAISONAI_TOOLS_AVAILABLE = True
+    except ImportError:
+        # If import fails, define BaseTool as a simple base class
+        class BaseTool:
+            pass
 
 os.environ["OTEL_SDK_DISABLED"] = "true"
 
@@ -40,11 +61,14 @@ def noop(*args, **kwargs):
     pass
 
 def disable_crewai_telemetry():
-    for attr in dir(Telemetry):
-        if callable(getattr(Telemetry, attr)) and not attr.startswith("__"):
-            setattr(Telemetry, attr, noop)
-            
-disable_crewai_telemetry()
+    if CREWAI_AVAILABLE:
+        for attr in dir(Telemetry):
+            if callable(getattr(Telemetry, attr)) and not attr.startswith("__"):
+                setattr(Telemetry, attr, noop)
+
+# Only disable telemetry if CrewAI is available
+if CREWAI_AVAILABLE:
+    disable_crewai_telemetry()
 
 class AgentsGenerator:
     def __init__(self, agent_file, framework, config_list, log_level=None, agent_callback=None, task_callback=None, agent_yaml=None, tools=None):
@@ -86,6 +110,12 @@ class AgentsGenerator:
         self.logger = logging.getLogger(__name__)
         self.logger.setLevel(self.log_level)
         
+        # Validate framework availability
+        if framework == "crewai" and not CREWAI_AVAILABLE:
+            raise ImportError("CrewAI is not installed. Please install it with 'pip install praisonai[crewai]'")
+        elif framework == "autogen" and not AUTOGEN_AVAILABLE:
+            raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
+
     def is_function_or_decorated(self, obj):
         """
         Checks if the given object is a function or has a __call__ method.
@@ -118,21 +148,21 @@ class AgentsGenerator:
     
     def load_tools_from_module_class(self, module_path):
         """
-        Loads tools from a specified module path containing classes that inherit from BaseTool or are part of langchain_community.tools package.
-
-        Parameters:
-            module_path (str): The path to the module containing the tools.
-
-        Returns:
-            dict: A dictionary containing the names of the tools as keys and the corresponding initialized instances of the classes as values.
-
-        Raises:
-            FileNotFoundError: If the specified module path does not exist.
+        Loads tools from a specified module path containing classes that inherit from BaseTool 
+        or are part of langchain_community.tools package.
         """
         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 (x.__module__.startswith('langchain_community.tools') or issubclass(x, BaseTool)) and x is not BaseTool)}
+        try:
+            spec.loader.exec_module(module)
+            return {name: obj() for name, obj in inspect.getmembers(module, 
+                lambda x: inspect.isclass(x) and (
+                    x.__module__.startswith('langchain_community.tools') or 
+                    (PRAISONAI_TOOLS_AVAILABLE and issubclass(x, BaseTool))
+                ) and x is not BaseTool)}
+        except ImportError as e:
+            self.logger.warning(f"Error loading tools from {module_path}: {e}")
+            return {}
 
     def load_tools_from_package(self, package_path):
         """
@@ -188,36 +218,37 @@ class AgentsGenerator:
                 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(),
-        }
-        
-        # Add tools from class names
-        for tool_class in self.tools:
-            if isinstance(tool_class, type) and issubclass(tool_class, BaseTool):
-                tool_name = tool_class.__name__
-                tools_dict[tool_name] = tool_class()
-                self.logger.debug(f"Added tool: {tool_name}")
+        tools_dict = {}
         
+        # Only try to use praisonai_tools if it's available and needed
+        if PRAISONAI_TOOLS_AVAILABLE and (CREWAI_AVAILABLE or AUTOGEN_AVAILABLE):
+            tools_dict = {
+                'CodeDocsSearchTool': CodeDocsSearchTool(),
+                'CSVSearchTool': CSVSearchTool(),
+                'DirectorySearchTool': DirectorySearchTool(),
+                'DOCXSearchTool': DOCXSearchTool(),
+                'DirectoryReadTool': DirectoryReadTool(),
+                'FileReadTool': FileReadTool(),
+                'TXTSearchTool': TXTSearchTool(),
+                'JSONSearchTool': JSONSearchTool(),
+                'MDXSearchTool': MDXSearchTool(),
+                'PDFSearchTool': PDFSearchTool(),
+                'RagTool': RagTool(),
+                'ScrapeElementFromWebsiteTool': ScrapeElementFromWebsiteTool(),
+                'ScrapeWebsiteTool': ScrapeWebsiteTool(),
+                'WebsiteSearchTool': WebsiteSearchTool(),
+                'XMLSearchTool': XMLSearchTool(),
+                'YoutubeChannelSearchTool': YoutubeChannelSearchTool(),
+                'YoutubeVideoSearchTool': YoutubeVideoSearchTool(),
+            }
+            
+            # Add tools from class names
+            for tool_class in self.tools:
+                if isinstance(tool_class, type) and issubclass(tool_class, BaseTool):
+                    tool_name = tool_class.__name__
+                    tools_dict[tool_name] = tool_class()
+                    self.logger.debug(f"Added tool: {tool_name}")
+
         root_directory = os.getcwd()
         tools_py_path = os.path.join(root_directory, 'tools.py')
         tools_dir_path = Path(root_directory) / 'tools'
@@ -231,162 +262,213 @@ class AgentsGenerator:
         
         framework = self.framework or config.get('framework')
 
+        if framework == "autogen":
+            if not AUTOGEN_AVAILABLE:
+                raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
+            if AGENTOPS_AVAILABLE:
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["autogen"])
+            return self._run_autogen(config, topic, tools_dict)
+        else:  # framework=crewai
+            if not CREWAI_AVAILABLE:
+                raise ImportError("CrewAI is not installed. Please install it with 'pip install praisonai[crewai]'")
+            if AGENTOPS_AVAILABLE:
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["crewai"])
+            return self._run_crewai(config, topic, tools_dict)
+
+    def _run_autogen(self, config, topic, tools_dict):
+        """
+        Run agents using the AutoGen framework.
+        
+        Args:
+            config (dict): Configuration dictionary
+            topic (str): The topic to process
+            tools_dict (dict): Dictionary of available tools
+            
+        Returns:
+            str: Result of the agent interactions
+        """
+        llm_config = {"config_list": self.config_list}
+        
+        # Set up user proxy agent
+        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,
+            }
+        )
+        
         agents = {}
         tasks = []
-        if framework == "autogen":
-            # Load the LLM configuration dynamically
-            # print(self.config_list)
-            llm_config = {"config_list": self.config_list}
+        
+        # Create agents and tasks from config
+        for role, details in config['roles'].items():
+            agent_name = details['role'].format(topic=topic).replace("{topic}", topic)
+            agent_goal = details['goal'].format(topic=topic)
             
-            if agentops_exists:
-                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["autogen"])
-            # 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
+            # Create AutoGen assistant agent
+            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 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
+            # Add tools to agent if specified
+            for tool in details.get('tools', []):
+                if tool in tools_dict:
+                    try:
+                        tool_class = globals()[f'autogen_{type(tools_dict[tool]).__name__}']
+                        self.logger.debug(f"Found {tool_class.__name__} for {tool}")
                         tool_class(agents[role], user_proxy)
+                    except KeyError:
+                        self.logger.warning(f"Warning: autogen_{type(tools_dict[tool]).__name__} function not found. Skipping this tool.")
+                        continue
+
+            # Prepare tasks
+            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",
+                }
+                tasks.append(chat_task)
+
+        # Execute tasks
+        response = user_proxy.initiate_chats(tasks)
+        result = "### Output ###\n" + response[-1].summary if hasattr(response[-1], 'summary') else ""
+        
+        if AGENTOPS_AVAILABLE:
+            agentops.end_session("Success")
+            
+        return result
 
-                # 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 ""
-            if agentops_exists:
-                agentops.end_session("Success")
-        else: # framework=crewai
-            if agentops_exists:
-                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["crewai"])
+    def _run_crewai(self, config, topic, tools_dict):
+        """
+        Run agents using the CrewAI framework.
+        
+        Args:
+            config (dict): Configuration dictionary
+            topic (str): The topic to process
+            tools_dict (dict): Dictionary of available tools
             
-            tasks_dict = {}
+        Returns:
+            str: Result of the agent interactions
+        """
+        agents = {}
+        tasks = []
+        tasks_dict = {}
+
+        # Create agents from config
+        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)
             
-            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]
-                
-                llm_model = details.get('llm')  # Get the llm configuration
-                if llm_model:
-                    llm = PraisonAIModel(
-                        model=llm_model.get("model", os.environ.get("MODEL_NAME", "openai/gpt-4o")),
-                    ).get_model()
-                else:
-                    llm = PraisonAIModel().get_model()
-
-                function_calling_llm_model = details.get('function_calling_llm')
-                if function_calling_llm_model:
-                    function_calling_llm = PraisonAIModel(
-                        model=function_calling_llm_model.get("model", os.environ.get("MODEL_NAME", "openai/gpt-4o")),
-                    ).get_model()
-                else:
-                    function_calling_llm = PraisonAIModel().get_model()
-                
-                agent = Agent(
-                    role=role_filled, 
-                    goal=goal_filled, 
-                    backstory=backstory_filled, 
-                    tools=agent_tools, 
-                    allow_delegation=details.get('allow_delegation', False),
-                    llm=llm,
-                    function_calling_llm=function_calling_llm,
-                    max_iter=details.get('max_iter', 15),
-                    max_rpm=details.get('max_rpm'),
-                    max_execution_time=details.get('max_execution_time'),
-                    verbose=details.get('verbose', True),
-                    cache=details.get('cache', True),
-                    system_template=details.get('system_template'),
-                    prompt_template=details.get('prompt_template'),
-                    response_template=details.get('response_template'),
-                )
-                
-                # Set agent callback if provided
-                if self.agent_callback:
-                    agent.step_callback = self.agent_callback
-
-                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,  # Clear, concise statement of what the task entails
-                        expected_output=expected_output_filled,  # Detailed description of what task's completion looks like
-                        agent=agent,  # The agent responsible for the task
-                        tools=task_details.get('tools', []),  # Functions or capabilities the agent can utilize
-                        async_execution=task_details.get('async_execution') if task_details.get('async_execution') is not None else False,  # Execute asynchronously if set
-                        context=[], ## TODO: 
-                        config=task_details.get('config') if task_details.get('config') is not None else {},  # Additional configuration details
-                        output_json=task_details.get('output_json') if task_details.get('output_json') is not None else None,  # Outputs a JSON object
-                        output_pydantic=task_details.get('output_pydantic') if task_details.get('output_pydantic') is not None else None,  # Outputs a Pydantic model object
-                        output_file=task_details.get('output_file') if task_details.get('output_file') is not None else "",  # Saves the task output to a file
-                        callback=task_details.get('callback') if task_details.get('callback') is not None else None,  # Python callable executed with the task's output
-                        human_input=task_details.get('human_input') if task_details.get('human_input') is not None else False,  # Indicates if the task requires human feedback
-                        create_directory=task_details.get('create_directory') if task_details.get('create_directory') is not None else False  # Indicates if a directory needs to be created
-                    )
-                    
-                    # Set tool callback if provided
-                    if self.task_callback:
-                        task.callback = self.task_callback
-
-                    tasks.append(task)
-                    tasks_dict[task_name] = task
+            # Get agent tools
+            agent_tools = [tools_dict[tool] for tool in details.get('tools', []) 
+                         if tool in tools_dict]
+            
+            # Configure LLM
+            llm_model = details.get('llm')
+            if llm_model:
+                llm = PraisonAIModel(
+                    model=llm_model.get("model", os.environ.get("MODEL_NAME", "openai/gpt-4o")),
+                ).get_model()
+            else:
+                llm = PraisonAIModel().get_model()
+
+            # Configure function calling LLM
+            function_calling_llm_model = details.get('function_calling_llm')
+            if function_calling_llm_model:
+                function_calling_llm = PraisonAIModel(
+                    model=function_calling_llm_model.get("model", os.environ.get("MODEL_NAME", "openai/gpt-4o")),
+                ).get_model()
+            else:
+                function_calling_llm = PraisonAIModel().get_model()
             
-            for role, details in config['roles'].items():
-                for task_name, task_details in details.get('tasks', {}).items():
-                    task = tasks_dict[task_name]
-                    context_tasks = [tasks_dict[ctx] for ctx in task_details.get('context', []) if ctx in tasks_dict]
-                    task.context = context_tasks
-
-            crew = Crew(
-                agents=list(agents.values()),
-                tasks=tasks,
-                verbose=2
+            # Create CrewAI agent
+            agent = Agent(
+                role=role_filled,
+                goal=goal_filled,
+                backstory=backstory_filled,
+                tools=agent_tools,
+                allow_delegation=details.get('allow_delegation', False),
+                llm=llm,
+                function_calling_llm=function_calling_llm,
+                max_iter=details.get('max_iter', 15),
+                max_rpm=details.get('max_rpm'),
+                max_execution_time=details.get('max_execution_time'),
+                verbose=details.get('verbose', True),
+                cache=details.get('cache', True),
+                system_template=details.get('system_template'),
+                prompt_template=details.get('prompt_template'),
+                response_template=details.get('response_template'),
             )
             
-            self.logger.debug("Final Crew Configuration:")
-            self.logger.debug(f"Agents: {crew.agents}")
-            self.logger.debug(f"Tasks: {crew.tasks}")
-
-            response = crew.kickoff()
-            result = f"### Task Output ###\n{response}"
-            if agentops_exists:
-                agentops.end_session("Success")
+            # Set agent callback if provided
+            if self.agent_callback:
+                agent.step_callback = self.agent_callback
+
+            agents[role] = agent
+
+            # Create tasks for the 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,
+                    tools=task_details.get('tools', []),
+                    async_execution=task_details.get('async_execution', False),
+                    context=[],
+                    config=task_details.get('config', {}),
+                    output_json=task_details.get('output_json'),
+                    output_pydantic=task_details.get('output_pydantic'),
+                    output_file=task_details.get('output_file', ""),
+                    callback=task_details.get('callback'),
+                    human_input=task_details.get('human_input', False),
+                    create_directory=task_details.get('create_directory', False)
+                )
+                
+                # Set task callback if provided
+                if self.task_callback:
+                    task.callback = self.task_callback
+
+                tasks.append(task)
+                tasks_dict[task_name] = task
+
+        # Set up task contexts
+        for role, details in config['roles'].items():
+            for task_name, task_details in details.get('tasks', {}).items():
+                task = tasks_dict[task_name]
+                context_tasks = [tasks_dict[ctx] for ctx in task_details.get('context', []) 
+                               if ctx in tasks_dict]
+                task.context = context_tasks
+
+        # Create and run the crew
+        crew = Crew(
+            agents=list(agents.values()),
+            tasks=tasks,
+            verbose=2
+        )
+        
+        self.logger.debug("Final Crew Configuration:")
+        self.logger.debug(f"Agents: {crew.agents}")
+        self.logger.debug(f"Tasks: {crew.tasks}")
+
+        response = crew.kickoff()
+        result = f"### Task Output ###\n{response}"
+        
+        if AGENTOPS_AVAILABLE:
+            agentops.end_session("Success")
+            
         return result
 

praisonai/auto.py

@@ -7,6 +7,36 @@ import json
 import yaml
 from rich import print
 import logging
+
+# Framework-specific imports with availability checks
+CREWAI_AVAILABLE = False
+AUTOGEN_AVAILABLE = False
+PRAISONAI_TOOLS_AVAILABLE = False
+
+try:
+    from crewai import Agent, Task, Crew
+    CREWAI_AVAILABLE = True
+except ImportError:
+    pass
+
+try:
+    import autogen
+    AUTOGEN_AVAILABLE = True
+except ImportError:
+    pass
+
+try:
+    from praisonai_tools import (
+        CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool,
+        DirectoryReadTool, FileReadTool, TXTSearchTool, JSONSearchTool,
+        MDXSearchTool, PDFSearchTool, RagTool, ScrapeElementFromWebsiteTool,
+        ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool,
+        YoutubeChannelSearchTool, YoutubeVideoSearchTool
+    )
+    PRAISONAI_TOOLS_AVAILABLE = True
+except ImportError:
+    PRAISONAI_TOOLS_AVAILABLE = False
+
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO').upper(), format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Define Pydantic models outside of the generate method
@@ -29,20 +59,26 @@ class AutoGenerator:
         """
         Initialize the AutoGenerator class with the specified topic, agent file, and framework.
         Note: autogen framework is different from this AutoGenerator class.
-
-        Args:
-            topic (str, optional): The topic for the generated team structure. Defaults to "Movie Story writing about AI".
-            agent_file (str, optional): The name of the YAML file to save the generated team structure. Defaults to "test.yaml".
-            framework (str, optional): The framework for the generated team structure. Defaults to "crewai".
-            config_list (Optional[List[Dict]], optional): A list containing the configuration details for the OpenAI API. 
-                                                          If None, it defaults to using environment variables or hardcoded values.
-        Attributes:
-            config_list (list): A list containing the configuration details for the OpenAI API.
-            topic (str): The specified topic for the generated team structure.
-            agent_file (str): The specified name of the YAML file to save the generated team structure.
-            framework (str): The specified framework for the generated team structure.
-            client (instructor.Client): An instance of the instructor.Client class initialized with the specified OpenAI API configuration.
         """
+        # Validate framework availability and show framework-specific messages
+        if framework == "crewai" and not CREWAI_AVAILABLE:
+            raise ImportError("""
+CrewAI is not installed. Please install with:
+    pip install "praisonai[crewai]"
+""")
+        elif framework == "autogen" and not AUTOGEN_AVAILABLE:
+            raise ImportError("""
+AutoGen is not installed. Please install with:
+    pip install "praisonai[autogen]"
+""")
+
+        # Only show tools message if using a framework and tools are needed
+        if (framework in ["crewai", "autogen"]) and not PRAISONAI_TOOLS_AVAILABLE:
+            logging.warning(f"""
+Tools are not available for {framework}. To use tools, install:
+    pip install "praisonai[{framework}]"
+""")
+
         self.config_list = config_list or [
             {
                 'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),