init

app.py

@@ -0,0 +1,60 @@
+import streamlit as st
+from streamlit import session_state as ss
+import db_utils
+from pg_agents import PageAgents
+from pg_tasks import PageTasks
+from pg_crews import PageCrews
+from pg_tools import PageTools
+from pg_crew_run import PageCrewRun
+from pg_export_crew import PageExportCrew
+from dotenv import load_dotenv
+import os
+def pages():
+    return {
+        'Crews': PageCrews(),
+        'Tools': PageTools(),
+        'Agents': PageAgents(),
+        'Tasks': PageTasks(),
+        'Kickoff!': PageCrewRun(),
+        'Import/export': PageExportCrew()
+    }
+
+def load_data():
+    ss.agents = db_utils.load_agents()
+    ss.tasks = db_utils.load_tasks()
+    ss.crews = db_utils.load_crews()
+    ss.tools = db_utils.load_tools()
+    ss.enabled_tools = db_utils.load_tools_state()
+
+
+def draw_sidebar():
+    with st.sidebar:
+        st.image("img/crewai_logo.png")
+
+        if 'page' not in ss:
+            ss.page = 'Crews'
+        
+        selected_page = st.radio('Page', list(pages().keys()), index=list(pages().keys()).index(ss.page),label_visibility="collapsed")
+        if selected_page != ss.page:
+            ss.page = selected_page
+            st.rerun()
+
+def main():
+    st.set_page_config(page_title="CrewAI Studio", page_icon="img/favicon.ico", layout="wide")
+    load_dotenv()
+    if (str(os.getenv('AGENTOPS_ENABLED')).lower() in ['true', '1']) and not ss.get('agentops_failed', False):
+        try:
+            import agentops
+            agentops.init(api_key=os.getenv('AGENTOPS_API_KEY'),auto_start_session=False)    
+        except ModuleNotFoundError as e:
+            ss.agentops_failed = True
+            print(f"Error initializing AgentOps: {str(e)}")            
+        
+    db_utils.initialize_db()
+    load_data()
+    draw_sidebar()
+    PageCrewRun.maintain_session_state() #this will persist the session state for the crew run page so crew run can be run in a separate thread
+    pages()[ss.page].draw()
+    
+if __name__ == '__main__':
+    main()

custom_tools.py

@@ -0,0 +1,272 @@
+import os
+from typing import Optional, Dict, Any, List, Type
+from crewai_tools import BaseTool
+import requests
+import importlib.util
+from pydantic.v1 import BaseModel, Field,root_validator, ValidationError
+import docker
+import base64
+
+class FixedCustomFileWriteToolInputSchema(BaseModel):
+    content: str = Field(..., description="The content to write or append to the file")
+    mode: str = Field(..., description="Mode to open the file in, either 'w' or 'a'")
+
+class CustomFileWriteToolInputSchema(FixedCustomFileWriteToolInputSchema):
+    content: str = Field(..., description="The content to write or append to the file")
+    mode: str = Field(..., description="Mode to open the file in, either 'w' or 'a'")
+    filename: str = Field(..., description="The name of the file to write to or append")
+
+class CustomFileWriteTool(BaseTool):
+    name: str = "Write File"
+    description: str = "Tool to write or append to files"
+    args_schema = CustomFileWriteToolInputSchema
+    filename: Optional[str] = None
+
+    def __init__(self, base_folder: str, filename: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+        if filename is not None and len(filename) > 0:
+            self.args_schema = FixedCustomFileWriteToolInputSchema
+        self._base_folder = base_folder
+        self.filename = filename or None
+        self._ensure_base_folder_exists()
+        self._generate_description()
+
+
+    def _ensure_base_folder_exists(self):
+        os.makedirs(self._base_folder, exist_ok=True)
+
+    def _get_full_path(self, filename: Optional[str]) -> str:
+        if filename is None and self.filename is None:
+            raise ValueError("No filename specified and no default file set.")
+
+        chosen_file = filename or self.filename
+        full_path = os.path.abspath(os.path.join(self._base_folder, chosen_file))
+
+        if not full_path.startswith(os.path.abspath(self._base_folder)):
+            raise ValueError("Access outside the base directory is not allowed.")  #TODO: add validations for path traversal
+
+        return full_path
+
+    def _run(self, content: str, mode: str, filename: Optional[str] = None) -> Dict[str, Any]:
+        full_path = self._get_full_path(filename)
+        try:
+            with open(full_path, 'a' if mode == 'a' else 'w') as file:
+                file.write(content)
+            return {
+                "status": "success",
+                "message": f"Content successfully {'appended to' if mode == 'a' else 'written to'} {full_path}"
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": str(e)
+            }
+
+    def run(self, input_data: CustomFileWriteToolInputSchema) -> Any:
+        response_data = self._run(
+            content=input_data.content,
+            mode=input_data.mode,
+            filename=input_data.filename
+        )
+        return response_data
+
+class CustomApiToolInputSchema(BaseModel):
+    endpoint: str = Field(..., description="The specific endpoint for the API call")
+    method: str = Field(..., description="HTTP method to use (GET, POST, PUT, DELETE)")
+    headers: Optional[Dict[str, str]] = Field(None, description="HTTP headers to include in the request")
+    query_params: Optional[Dict[str, Any]] = Field(None, description="Query parameters for the request")
+    body: Optional[Dict[str, Any]] = Field(None, description="Body of the request for POST/PUT methods")
+
+class CustomApiTool(BaseTool):
+    name: str = "Call Api"
+    description: str = "Tool to make API calls with customizable parameters"
+    args_schema = CustomApiToolInputSchema
+    base_url: Optional[str] = None
+    default_headers: Optional[Dict[str, str]] = None
+    default_query_params: Optional[Dict[str, Any]] = None
+
+    def __init__(self, base_url: Optional[str] = None, headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, Any]] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.base_url = base_url
+        self.default_headers = headers or {}
+        self.default_query_params = query_params or {}
+        self._generate_description()
+        
+
+    def _run(self, endpoint: str, method: str, headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, Any]] = None, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.base_url}/{endpoint}".rstrip("/")
+        headers = {**self.default_headers, **(headers or {})}
+        query_params = {**self.default_query_params, **(query_params or {})}
+
+        try:
+            response = requests.request(
+                method=method.upper(),
+                url=url,
+                headers=headers,
+                params=query_params,
+                json=body,
+                verify=False #TODO: add option to disable SSL verification
+            )
+            return {
+                "status_code": response.status_code,
+                "response": response.json() if response.headers.get("Content-Type") == "application/json" else response.text
+            }
+        except Exception as e:
+            return {
+                "status_code": 500,
+                "response": str(e)
+            }
+
+    def run(self, input_data: CustomApiToolInputSchema) -> Any:
+        response_data = self._run(
+            endpoint=input_data.endpoint,
+            method=input_data.method,
+            headers=input_data.headers,
+            query_params=input_data.query_params,
+            body=input_data.body
+            
+        )
+        return response_data
+
+class CustomCodeInterpreterSchema(BaseModel):
+    """Input for CustomCodeInterpreterTool."""
+    code: Optional[str] = Field(
+        None,
+        description="Python3 code used to be interpreted in the Docker container. ALWAYS PRINT the final result and the output of the code",
+    )
+
+    run_script: Optional[str] = Field(
+        None,
+        description="Relative path to the script to run in the Docker container. The script should contain the code to be executed.",
+    )
+
+    libraries_used: str = Field(
+        ...,
+        description="List of libraries used in the code with proper installing names separated by commas. Example: numpy,pandas,beautifulsoup4",
+    )
+
+    @root_validator
+    def check_code_or_run_script(cls, values):
+        code = values.get('code')
+        run_script = values.get('run_script')
+        if not code and not run_script:
+            raise ValueError('Either code or run_script must be provided')
+        if code and run_script:
+            raise ValueError('Only one of code or run_script should be provided')
+        return values
+
+class CustomCodeInterpreterTool(BaseTool):
+    name: str = "Code Interpreter"
+    description: str = "Interprets Python3 code strings with a final print statement. Requires eighter code or run_script to be provided."
+    args_schema: Type[BaseModel] = CustomCodeInterpreterSchema
+    code: Optional[str] = None
+    run_script: Optional[str] = None
+    workspace_dir: Optional[str] = None
+
+    def __init__(self, workspace_dir: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+        if workspace_dir is not None and len(workspace_dir) > 0:
+            self.workspace_dir = os.path.abspath(workspace_dir)
+            os.makedirs(self.workspace_dir, exist_ok=True)
+        self._generate_description()
+
+    @staticmethod
+    def _get_installed_package_path():
+        spec = importlib.util.find_spec('crewai_tools')
+        return os.path.dirname(spec.origin)
+
+    def _verify_docker_image(self) -> None:
+        """
+        Verify if the Docker image is available
+        """
+        image_tag = "code-interpreter:latest"
+        client = docker.from_env()
+
+        try:
+            client.images.get(image_tag)
+
+        except docker.errors.ImageNotFound:
+            package_path = self._get_installed_package_path()
+            dockerfile_path = os.path.join(package_path, "tools/code_interpreter_tool")
+            if not os.path.exists(dockerfile_path):
+                raise FileNotFoundError(f"Dockerfile not found in {dockerfile_path}")
+
+            client.images.build(
+                path=dockerfile_path,
+                tag=image_tag,
+                rm=True,
+            )
+
+    def _install_libraries(
+        self, container: docker.models.containers.Container, libraries: str
+    ) -> None:
+        """
+        Install missing libraries in the Docker container
+        """
+        if libraries and len(libraries) > 0:
+            for library in libraries.split(","):
+                print(f"Installing library: {library}")
+                install_result = container.exec_run(f"pip install {library}")
+                if install_result.exit_code != 0:
+                    print(f"Something went wrong while installing the library: {library}")
+                    print(install_result.output.decode("utf-8"))
+            
+
+    def _get_existing_container(self, container_name: str) -> Optional[docker.models.containers.Container]:
+        client = docker.from_env()
+        try:
+            existing_container = client.containers.get(container_name)
+            if existing_container.status == 'running':
+                return existing_container
+            if existing_container.status == 'exited':
+                existing_container.remove()
+        except docker.errors.NotFound:
+            pass
+        return None
+
+    def _init_docker_container(self) -> docker.models.containers.Container:
+        client = docker.from_env()
+        volumes = {}
+        if self.workspace_dir:
+            volumes[self.workspace_dir] = {"bind": "/workspace", "mode": "rw"}
+        container_name = "custom-code-interpreter"
+        existing_container = self._get_existing_container(container_name)
+        if existing_container:
+            return existing_container
+        return client.containers.run(
+            "code-interpreter", detach=True, tty=True, working_dir="/workspace", name=container_name, volumes=volumes
+        )
+
+    def run_code_in_docker(self, code: str, libraries_used: str) -> str:
+        self._verify_docker_image()
+        container = self._init_docker_container()
+        self._install_libraries(container, libraries_used)
+        
+        # Encode the code to base64
+        encoded_code = base64.b64encode(code.encode('utf-8')).decode('utf-8')
+        
+        # Create a command to decode the base64 string and run the Python code
+        cmd_to_run = f'python3 -c "import base64; exec(base64.b64decode(\'{encoded_code}\').decode(\'utf-8\'))"'
+        
+        print(f"Running code in container: \n{code}")
+        
+        exec_result = container.exec_run(cmd_to_run)
+
+        if exec_result.exit_code != 0:
+            print(f"Something went wrong while running the code: \n{exec_result.output.decode('utf-8')}")
+            return f"Something went wrong while running the code: \n{exec_result.output.decode('utf-8')}"
+        print(f"Code run output: \n{exec_result.output.decode('utf-8')}")
+        return exec_result.output.decode("utf-8")
+    
+    def _run_script(self, run_script: str,libraries_used: str) -> str:
+        with open(f"{self.workspace_dir}/{run_script}", "r") as file:
+            code = file.read()
+            return self.run_code_in_docker(code, libraries_used)
+
+    def _run(self, **kwargs) -> str:
+        code = kwargs.get("code", self.code)
+        run_script = kwargs.get("run_script", self.run_script)
+        libraries_used = kwargs.get("libraries_used", [])
+        if run_script:
+            return self._run_script(run_script, libraries_used)
+        return self.run_code_in_docker(code, libraries_used)

db_utils.py

@@ -0,0 +1,239 @@
+import sqlite3
+import os
+import json
+from my_tools import TOOL_CLASSES
+
+DB_NAME = 'crewai.db'
+
+def get_db_connection():
+    conn = sqlite3.connect(DB_NAME)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def create_tables():
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS entities (
+            id TEXT PRIMARY KEY,
+            entity_type TEXT,
+            data TEXT
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+def initialize_db():
+    if not os.path.exists(DB_NAME):
+        create_tables()
+    else:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute('SELECT name FROM sqlite_master WHERE type="table" AND name="entities"')
+        table_exists = cursor.fetchone()
+        if not table_exists:
+            create_tables()
+        conn.close()
+
+def save_entity(entity_type, entity_id, data):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute('''
+        INSERT OR REPLACE INTO entities (id, entity_type, data)
+        VALUES (?, ?, ?)
+    ''', (entity_id, entity_type, json.dumps(data)))
+    conn.commit()
+    conn.close()
+
+def load_entities(entity_type):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute('SELECT * FROM entities WHERE entity_type = ?', (entity_type,))
+    rows = cursor.fetchall()
+    conn.close()
+    return [(row['id'], json.loads(row['data'])) for row in rows]
+
+def delete_entity(entity_type, entity_id):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute('''
+        DELETE FROM entities WHERE id = ? AND entity_type = ?
+    ''', (entity_id, entity_type))
+    conn.commit()
+    conn.close()
+
+def save_tools_state(enabled_tools):
+    data = {
+        'enabled_tools': enabled_tools
+    }
+    save_entity('tools_state', 'enabled_tools', data)
+
+def load_tools_state():
+    rows = load_entities('tools_state')
+    if rows:
+        return rows[0][1].get('enabled_tools', {})
+    return {}
+
+def save_agent(agent):
+    data = {
+        'created_at': agent.created_at,
+        'role': agent.role,
+        'backstory': agent.backstory,
+        'goal': agent.goal,
+        'allow_delegation': agent.allow_delegation,
+        'verbose': agent.verbose,
+        'cache': agent.cache,
+        'llm_provider_model': agent.llm_provider_model,
+        'temperature': agent.temperature,
+        'max_iter': agent.max_iter,
+        'tool_ids': [tool.tool_id for tool in agent.tools]  # Save tool IDs
+    }
+    save_entity('agent', agent.id, data)
+
+def load_agents():
+    from my_agent import MyAgent
+    rows = load_entities('agent')
+    tools_dict = {tool.tool_id: tool for tool in load_tools()}
+    agents = []
+    for row in rows:
+        data = row[1]
+        tool_ids = data.pop('tool_ids', [])
+        agent = MyAgent(id=row[0], **data)
+        agent.tools = [tools_dict[tool_id] for tool_id in tool_ids if tool_id in tools_dict]
+        agents.append(agent)
+    return sorted(agents, key=lambda x: x.created_at)
+
+def delete_agent(agent_id):
+    delete_entity('agent', agent_id)
+
+def save_task(task):
+    data = {
+        'description': task.description,
+        'expected_output': task.expected_output,
+        'async_execution': task.async_execution,
+        'agent_id': task.agent.id if task.agent else None,
+        'context_from_async_tasks_ids': task.context_from_async_tasks_ids,
+        'context_from_sync_tasks_ids': task.context_from_sync_tasks_ids,
+        'created_at': task.created_at
+    }
+    save_entity('task', task.id, data)
+
+def load_tasks():
+    from my_task import MyTask
+    rows = load_entities('task')
+    agents_dict = {agent.id: agent for agent in load_agents()}
+    tasks = []
+    for row in rows:
+        data = row[1]
+        agent_id = data.pop('agent_id', None)
+        task = MyTask(id=row[0], agent=agents_dict.get(agent_id), **data)
+        tasks.append(task)
+    return sorted(tasks, key=lambda x: x.created_at)
+
+def delete_task(task_id):
+    delete_entity('task', task_id)
+
+def save_crew(crew):
+    data = {
+        'name': crew.name,
+        'process': crew.process,
+        'verbose': crew.verbose,
+        'agent_ids': [agent.id for agent in crew.agents],
+        'task_ids': [task.id for task in crew.tasks],
+        'memory': crew.memory,
+        'cache': crew.cache,
+        'planning': crew.planning,
+        'max_rpm' : crew.max_rpm,
+        'manager_llm': crew.manager_llm,
+        'manager_agent_id': crew.manager_agent.id if crew.manager_agent else None,
+        'created_at': crew.created_at
+    }
+    save_entity('crew', crew.id, data)
+
+def load_crews():
+    from my_crew import MyCrew
+    rows = load_entities('crew')
+    agents_dict = {agent.id: agent for agent in load_agents()}
+    tasks_dict = {task.id: task for task in load_tasks()}
+    crews = []
+    for row in rows:
+        data = row[1]
+        crew = MyCrew(
+            id=row[0], 
+            name=data['name'], 
+            process=data['process'], 
+            verbose=data['verbose'], 
+            created_at=data['created_at'], 
+            memory=data.get('memory'),
+            cache=data.get('cache'),
+            planning=data.get('planning'),
+            max_rpm=data.get('max_rpm'), 
+            manager_llm=data.get('manager_llm'),
+            manager_agent=agents_dict.get(data.get('manager_agent_id'))
+        )
+        crew.agents = [agents_dict[agent_id] for agent_id in data['agent_ids'] if agent_id in agents_dict]
+        crew.tasks = [tasks_dict[task_id] for task_id in data['task_ids'] if task_id in tasks_dict]
+        crews.append(crew)
+    return sorted(crews, key=lambda x: x.created_at)
+
+def delete_crew(crew_id):
+    delete_entity('crew', crew_id)
+
+def save_tool(tool):
+    data = {
+        'name': tool.name,
+        'description': tool.description,
+        'parameters': tool.get_parameters()
+    }
+    save_entity('tool', tool.tool_id, data)
+
+def load_tools():
+    rows = load_entities('tool')
+    tools = []
+    for row in rows:
+        data = row[1]
+        tool_class = TOOL_CLASSES[data['name']]
+        tool = tool_class(tool_id=row[0])
+        tool.set_parameters(**data['parameters'])
+        tools.append(tool)
+    return tools
+
+def delete_tool(tool_id):
+    delete_entity('tool', tool_id)
+
+def export_to_json(file_path):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute('SELECT * FROM entities')
+    rows = cursor.fetchall()
+    conn.close()
+
+    data = []
+    for row in rows:
+        entity = {
+            'id': row['id'],
+            'entity_type': row['entity_type'],
+            'data': json.loads(row['data'])
+        }
+        data.append(entity)
+
+    with open(file_path, 'w') as f:
+        json.dump(data, f, indent=4)
+
+def import_from_json(file_path):
+    with open(file_path, 'r') as f:
+        data = json.load(f)
+
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    for entity in data:
+        cursor.execute('''
+            INSERT OR REPLACE INTO entities (id, entity_type, data)
+            VALUES (?, ?, ?)
+        ''', (entity['id'], entity['entity_type'], json.dumps(entity['data'])))
+
+    conn.commit()
+    conn.close()

llms.py

@@ -0,0 +1,106 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_groq import ChatGroq
+from langchain_anthropic import ChatAnthropic
+
+#from langchain_google_genai import ChatGoogleGenerativeAI
+# from langchain_huggingface import ChatHuggingFace
+from dotenv import load_dotenv
+
+def create_openai_llm(model, temperature):
+    safe_pop_env_var('OPENAI_API_KEY')
+    safe_pop_env_var('OPENAI_API_BASE')
+    load_dotenv(override=True)
+    api_key = os.getenv('OPENAI_API_KEY')
+    api_base = os.getenv('OPENAI_API_BASE', 'https://api.openai.com/v1/')
+  
+    if model == "gpt-4o-mini":
+        max_tokens = 16383
+    else:
+        max_tokens = 4095
+    if api_key:
+        return ChatOpenAI(openai_api_key=api_key, openai_api_base=api_base, model_name=model, temperature=temperature, max_tokens=max_tokens)
+    else:
+        raise ValueError("OpenAI API key not set in .env file")
+
+def create_anthropic_llm(model, temperature):
+    api_key = os.getenv('ANTHROPIC_API_KEY')
+    if api_key:
+        return ChatAnthropic(anthropic_api_key=api_key, model_name=model, temperature=temperature,max_tokens=4095)
+    else:
+        raise ValueError("Anthropic API key not set in .env file")
+
+def create_groq_llm(model, temperature):
+    api_key = os.getenv('GROQ_API_KEY')
+    if api_key:
+        return ChatGroq(groq_api_key=api_key, model_name=model, temperature=temperature, max_tokens=4095)
+    else:
+        raise ValueError("Groq API key not set in .env file")
+    
+# def create_googleai_llm(model, temperature):
+#     api_key = os.getenv('GOOGLE_API_KEY')
+#     if api_key:        
+#          return ChatGoogleGenerativeAI(model=model, temperature=temperature)
+#     else:
+#         raise ValueError("Google AI API key not set in .env file")
+
+# def create_huggingfacehub_llm(model, temperature):
+#     api_key = os.getenv('HUGGINGFACEHUB_API_KEY')
+#     if api_key:
+#         return ChatHuggingFace(repo_id=model, huggingfacehub_api_token=api_key,  model_kwargs={"temperature":temperature, "max_tokens": 4096})
+#     else:
+#         raise ValueError("HuggingFace API key not set in .env file")
+
+def create_lmstudio_llm(model, temperature):
+    api_base = os.getenv('LMSTUDIO_API_BASE')
+    os.environ["OPENAI_API_KEY"] = "lm-studio"
+    os.environ["OPENAI_API_BASE"] = api_base
+    if api_base:
+        return ChatOpenAI(openai_api_key='lm-studio', openai_api_base=api_base, temperature=temperature, max_tokens=4095)
+    else:
+        raise ValueError("LM Studio API base not set in .env file")
+
+LLM_CONFIG = {
+    "OpenAI": {
+        "models": ["gpt-4o","gpt-4o-mini","gpt-3.5-turbo", "gpt-4-turbo"],
+        "create_llm": create_openai_llm
+    },
+    "Groq": {
+        "models": ["llama3-8b-8192","llama3-70b-8192", "mixtral-8x7b-32768"],
+        "create_llm": create_groq_llm
+    },
+    # "GoogleAI": {
+    #     "models": ["gemini-1.5-pro","gemini-1.5-flash", "gemini-1.0-pro"],
+    #     "create_llm": create_googleai_llm
+    # },
+    # "HuggingFaceHub": {
+    #     "models": ["mistralai/Mistral-7B-Instruct-v0.2", "mistralai/Codestral-22B-v0.1", "EleutherAI/gpt-neo-2.7B"],
+    #     "create_llm": create_huggingfacehub_llm
+    # },
+    "Anthropic": {
+        "models": ["claude-3-5-sonnet-20240620"],
+        "create_llm": create_anthropic_llm
+    },
+    "LM Studio": {
+        "models": ["lms-default"],
+        "create_llm": create_lmstudio_llm
+    }
+
+}
+
+def llm_providers_and_models():
+    return [f"{provider}: {model}" for provider in LLM_CONFIG.keys() for model in LLM_CONFIG[provider]["models"]]
+
+def create_llm(provider_and_model, temperature=0.1):
+    provider, model = provider_and_model.split(": ")
+    create_llm_func = LLM_CONFIG.get(provider, {}).get("create_llm")
+    if create_llm_func:
+        return create_llm_func(model, temperature)
+    else:
+        raise ValueError(f"LLM provider {provider} is not recognized or not supported")
+      
+def safe_pop_env_var(key):
+    try:
+        os.environ.pop(key)
+    except KeyError:
+        pass

my_agent.py

@@ -0,0 +1,124 @@
+from crewai import Agent
+import streamlit as st
+from utils import rnd_id, fix_columns_width
+from streamlit import session_state as ss
+from db_utils import save_agent, delete_agent
+from llms import llm_providers_and_models, create_llm
+from datetime import datetime
+
+class MyAgent:
+    def __init__(self, id=None, role=None, backstory=None, goal=None, temperature=None, allow_delegation=False, verbose=False, cache= None, llm_provider_model=None, max_iter=None, created_at=None, tools=None):
+        self.id = id or "A_" + rnd_id()
+        self.role = role or "Senior Researcher"
+        self.backstory = backstory or "Driven by curiosity, you're at the forefront of innovation, eager to explore and share knowledge that could change the world."
+        self.goal = goal or "Uncover groundbreaking technologies in AI"
+        self.temperature = temperature or 0.1
+        self.allow_delegation = allow_delegation if allow_delegation is not None else False
+        self.verbose = verbose if verbose is not None else True
+        self.llm_provider_model = llm_providers_and_models()[0] if llm_provider_model is None else llm_provider_model
+        self.created_at = created_at or datetime.now().isoformat()
+        self.tools = tools or []
+        self.max_iter = max_iter or 25
+        self.cache = cache if cache is not None else True
+        self.edit_key = f'edit_{self.id}'
+        if self.edit_key not in ss:
+            ss[self.edit_key] = False
+
+    @property
+    def edit(self):
+        return ss[self.edit_key]
+
+    @edit.setter
+    def edit(self, value):
+        ss[self.edit_key] = value
+
+    def get_crewai_agent(self) -> Agent:
+            llm = create_llm(self.llm_provider_model, temperature=self.temperature)
+            tools = [tool.create_tool() for tool in self.tools]
+            return Agent(
+                role=self.role,
+                backstory=self.backstory,
+                goal=self.goal,
+                allow_delegation=self.allow_delegation,
+                verbose=self.verbose,
+                max_iter=self.max_iter,
+                cache=self.cache,
+                tools=tools,
+                llm=llm
+            )
+
+    def delete(self):
+        ss.agents = [agent for agent in ss.agents if agent.id != self.id]
+        delete_agent(self.id)
+
+    def get_tool_display_name(self, tool):
+        first_param_name = tool.get_parameter_names()[0] if tool.get_parameter_names() else None
+        first_param_value = tool.parameters.get(first_param_name, '') if first_param_name else ''
+        return f"{tool.name} ({first_param_value if first_param_value else tool.tool_id})"
+
+    def is_valid(self, show_warning=False):
+        for tool in self.tools:
+            if not tool.is_valid(show_warning=show_warning):
+                if show_warning:
+                    st.warning(f"Tool {tool.name} is not valid")
+                return False
+        return True
+
+    def validate_llm_provider_model(self):
+        available_models = llm_providers_and_models()
+        if self.llm_provider_model not in available_models:
+            self.llm_provider_model = available_models[0]
+
+    def draw(self, key=None):
+        self.validate_llm_provider_model()
+        expander_title = f"{self.role[:60]} -{self.llm_provider_model.split(':')[1]}" if self.is_valid() else f"❗ {self.role[:20]} -{self.llm_provider_model.split(':')[1]}"
+        if self.edit:
+            with st.expander(f"Agent: {self.role}", expanded=True):
+                with st.form(key=f'form_{self.id}' if key is None else key):
+                    self.role = st.text_input("Role", value=self.role)
+                    self.backstory = st.text_area("Backstory", value=self.backstory)
+                    self.goal = st.text_area("Goal", value=self.goal)
+                    self.allow_delegation = st.checkbox("Allow delegation", value=self.allow_delegation)
+                    self.verbose = st.checkbox("Verbose", value=self.verbose)
+                    self.cache = st.checkbox("Cache", value=self.cache)
+                    self.llm_provider_model = st.selectbox("LLM Provider and Model", options=llm_providers_and_models(), index=llm_providers_and_models().index(self.llm_provider_model))
+                    self.temperature = st.slider("Temperature", value=self.temperature, min_value=0.0, max_value=1.0)
+                    self.max_iter = st.number_input("Max Iterations", value=self.max_iter, min_value=1, max_value=100)
+                    enabled_tools = [tool for tool in ss.tools]
+                    selected_tools = st.multiselect(
+                        "Select Tools",
+                        [self.get_tool_display_name(tool) for tool in enabled_tools],
+                        default=[self.get_tool_display_name(tool) for tool in self.tools],
+                        key=f"{self.id}_tools{key}"
+                    )
+                    submitted = st.form_submit_button("Save")
+                    if submitted:
+                        self.tools = [tool for tool in enabled_tools if self.get_tool_display_name(tool) in selected_tools]
+                        self.set_editable(False)
+        else:
+            fix_columns_width()
+            with st.expander(expander_title, expanded=False):
+                st.markdown(f"**Role:** {self.role}")
+                st.markdown(f"**Backstory:** {self.backstory}")
+                st.markdown(f"**Goal:** {self.goal}")
+                st.markdown(f"**Allow delegation:** {self.allow_delegation}")
+                st.markdown(f"**Verbose:** {self.verbose}")
+                st.markdown(f"**Cache:** {self.cache}")
+                st.markdown(f"**LLM Provider and Model:** {self.llm_provider_model}")
+                st.markdown(f"**Temperature:** {self.temperature}")
+                st.markdown(f"**Max Iterations:** {self.max_iter}")
+                st.markdown(f"**Tools:** {[self.get_tool_display_name(tool) for tool in self.tools]}")
+
+                self.is_valid(show_warning=True)
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.button("Edit", on_click=self.set_editable, args=(True,), key=rnd_id())
+                with col2:
+                    st.button("Delete", on_click=self.delete, key=rnd_id())
+
+    def set_editable(self, edit):
+        self.edit = edit
+        save_agent(self)
+        if not edit:
+            st.rerun()

my_crew.py

@@ -0,0 +1,262 @@
+from crewai import Crew, Process
+import streamlit as st
+from utils import rnd_id, fix_columns_width
+from streamlit import session_state as ss
+from datetime import datetime
+from llms import llm_providers_and_models, create_llm
+import db_utils
+
+class MyCrew:
+    def __init__(self, id=None, name=None, agents=None, tasks=None, process=None, cache=None,max_rpm=None, verbose=None, manager_llm=None, manager_agent=None, created_at=None, memory=None, planning=None):
+        self.id = id or "C_" + rnd_id()
+        self.name = name or "Crew 1"
+        self.agents = agents or []
+        self.tasks = tasks or []
+        self.process = process or Process.sequential
+        self.verbose = bool(verbose) if verbose is not None else True
+        self.manager_llm = manager_llm
+        self.manager_agent = manager_agent
+        self.memory = memory if memory is not None else False
+        self.cache = cache if cache is not None else True
+        self.max_rpm = max_rpm or 1000
+        self.planning = planning if planning is not None else False
+        self.created_at = created_at or datetime.now().isoformat()
+        self.edit_key = f'edit_{self.id}'
+        if self.edit_key not in ss:
+            ss[self.edit_key] = False
+        self.tasks_order_key = f'tasks_order_{self.id}'
+        if self.tasks_order_key not in ss:
+            ss[self.tasks_order_key] = [task.id for task in self.tasks]
+
+    @property
+    def edit(self):
+        return ss[self.edit_key]
+
+    @edit.setter
+    def edit(self, value):
+        ss[self.edit_key] = value
+
+    def get_crewai_crew(self, *args, **kwargs) -> Crew:
+        crewai_agents = [agent.get_crewai_agent() for agent in self.agents]
+
+        # Create a dictionary to hold the Task objects
+        task_objects = {}
+
+        def create_task(task):
+            if task.id in task_objects:
+                return task_objects[task.id]
+
+            context_tasks = []
+            if task.async_execution or task.context_from_async_tasks_ids or task.context_from_sync_tasks_ids:
+                for context_task_id in (task.context_from_async_tasks_ids or []) + (task.context_from_sync_tasks_ids or []):
+                    if context_task_id not in task_objects:
+                        context_task = next((t for t in self.tasks if t.id == context_task_id), None)
+                        if context_task:
+                            context_tasks.append(create_task(context_task))
+                        else:
+                            print(f"Warning: Context task with id {context_task_id} not found for task {task.id}")
+                    else:
+                        context_tasks.append(task_objects[context_task_id])
+
+            # Only pass context if it's an async task or if specific context is defined
+            if task.async_execution or context_tasks:
+                crewai_task = task.get_crewai_task(context_from_async_tasks=context_tasks)
+            else:
+                crewai_task = task.get_crewai_task()
+
+            task_objects[task.id] = crewai_task
+            return crewai_task
+
+        # Create all tasks, resolving dependencies recursively
+        for task in self.tasks:
+            create_task(task)
+
+        # Collect the final list of tasks in the original order
+        crewai_tasks = [task_objects[task.id] for task in self.tasks]
+
+        if self.manager_llm:
+            return Crew(
+                agents=crewai_agents,
+                tasks=crewai_tasks,
+                cache=self.cache,
+                process=self.process,
+                max_rpm=self.max_rpm,
+                verbose=self.verbose,
+                manager_llm=create_llm(self.manager_llm),
+                memory=self.memory,
+                planning=self.planning,
+                *args, **kwargs
+            )
+        elif self.manager_agent:
+            return Crew(
+                agents=crewai_agents,
+                tasks=crewai_tasks,
+                cache=self.cache,
+                process=self.process,
+                max_rpm=self.max_rpm,
+                verbose=self.verbose,
+                manager_agent=self.manager_agent.get_crewai_agent(),
+                memory=self.memory,
+                planning=self.planning,
+                *args, **kwargs
+            )
+        cr = Crew(
+        agents=crewai_agents,
+        tasks=crewai_tasks,
+        cache=self.cache,
+        process=self.process,
+        max_rpm=self.max_rpm,
+        verbose=self.verbose,
+        memory=self.memory,
+        planning=self.planning,
+        *args, **kwargs
+        )
+        return cr
+    
+    def delete(self):
+        ss.crews = [crew for crew in ss.crews if crew.id != self.id]
+        db_utils.delete_crew(self.id)
+
+    def update_name(self):
+        self.name = ss[f'name_{self.id}']
+        db_utils.save_crew(self)
+
+    def update_process(self):
+        self.process = ss[f'process_{self.id}']
+        db_utils.save_crew(self)
+
+    def update_tasks(self):
+        selected_tasks_ids = ss[f'tasks_{self.id}']
+        self.tasks = [task for task in ss.tasks if task.id in selected_tasks_ids and task.agent.id in [agent.id for agent in self.agents]]
+        self.tasks = sorted(self.tasks, key=lambda task: selected_tasks_ids.index(task.id))
+        ss[self.tasks_order_key] = selected_tasks_ids
+        db_utils.save_crew(self)
+
+    def update_verbose(self):
+        self.verbose = ss[f'verbose_{self.id}']
+        db_utils.save_crew(self)
+
+    def update_agents(self):
+        selected_agents = ss[f'agents_{self.id}']
+        self.agents = [agent for agent in ss.agents if agent.role in selected_agents]        
+        db_utils.save_crew(self)
+
+    def update_manager_llm(self):
+        selected_llm = ss[f'manager_llm_{self.id}']
+        self.manager_llm = selected_llm if selected_llm != "None" else None
+        if self.manager_llm:
+            self.manager_agent = None
+        db_utils.save_crew(self)
+
+    def update_manager_agent(self):
+        selected_agent_role = ss[f'manager_agent_{self.id}']
+        self.manager_agent = next((agent for agent in ss.agents if agent.role == selected_agent_role), None) if selected_agent_role != "None" else None
+        if self.manager_agent:
+            self.manager_llm = None
+        db_utils.save_crew(self)
+
+    def update_memory(self):
+        self.memory = ss[f'memory_{self.id}']
+        db_utils.save_crew(self)
+    
+    def update_max_rpm(self):
+        self.max_rpm = ss[f'max_rpm_{self.id}']
+        db_utils.save_crew(self)
+
+    def update_cache(self):
+        self.cache = ss[f'cache_{self.id}']
+        db_utils.save_crew(self)
+
+    def update_planning(self):
+        self.planning = ss[f'planning_{self.id}']
+        db_utils.save_crew(self)
+
+    def is_valid(self, show_warning=False):
+        if len(self.agents) == 0:
+            if show_warning:
+                st.warning(f"Crew {self.name} has no agents")
+            return False
+        if len(self.tasks) == 0:
+            if show_warning:
+                st.warning(f"Crew {self.name} has no tasks")
+            return False
+        if any([not agent.is_valid(show_warning=show_warning) for agent in self.agents]):
+            return False
+        if any([not task.is_valid(show_warning=show_warning) for task in self.tasks]):
+            return False
+        if self.process == Process.hierarchical and not (self.manager_llm or self.manager_agent):
+            if show_warning:
+                st.warning(f"Crew {self.name} has no manager agent or manager llm set for hierarchical process")
+            return False
+        return True
+
+    def validate_manager_llm(self):
+        available_models = llm_providers_and_models()
+        if self.manager_llm and self.manager_llm not in available_models:
+            self.manager_llm = None
+
+    def draw(self,expanded=False, buttons=True):
+        self.validate_manager_llm()
+        name_key = f"name_{self.id}"
+        process_key = f"process_{self.id}"
+        verbose_key = f"verbose_{self.id}"
+        agents_key = f"agents_{self.id}"
+        tasks_key = f"tasks_{self.id}"
+        manager_llm_key = f"manager_llm_{self.id}"
+        manager_agent_key = f"manager_agent_{self.id}"
+        memory_key = f"memory_{self.id}"
+        planning_key = f"planning_{self.id}"
+        cache_key = f"cache_{self.id}"
+        max_rpm_key = f"max_rpm_{self.id}"
+        
+        if self.edit:
+            with st.container(border=True):
+                st.text_input("Name (just id, it doesn't affect anything)", value=self.name, key=name_key, on_change=self.update_name)
+                st.selectbox("Process", options=[Process.sequential, Process.hierarchical], index=[Process.sequential, Process.hierarchical].index(self.process), key=process_key, on_change=self.update_process)
+                st.multiselect("Agents", options=[agent.role for agent in ss.agents], default=[agent.role for agent in self.agents], key=agents_key, on_change=self.update_agents)                
+                # Filter tasks by selected agents
+                available_tasks = [task for task in ss.tasks if task.agent and task.agent.id in [agent.id for agent in self.agents]]
+                available_task_ids = [task.id for task in available_tasks]
+                default_task_ids = [task.id for task in self.tasks if task.id in available_task_ids]             
+                st.multiselect("Tasks", options=available_task_ids, default=default_task_ids, format_func=lambda x: next(task.description for task in ss.tasks if task.id == x), key=tasks_key, on_change=self.update_tasks)                
+                st.selectbox("Manager LLM", options=["None"] + llm_providers_and_models(), index=0 if self.manager_llm is None else llm_providers_and_models().index(self.manager_llm) + 1, key=manager_llm_key, on_change=self.update_manager_llm, disabled=(self.process != Process.hierarchical))
+                st.selectbox("Manager Agent", options=["None"] + [agent.role for agent in ss.agents], index=0 if self.manager_agent is None else [agent.role for agent in ss.agents].index(self.manager_agent.role) + 1, key=manager_agent_key, on_change=self.update_manager_agent, disabled=(self.process != Process.hierarchical))
+                st.checkbox("Verbose", value=self.verbose, key=verbose_key, on_change=self.update_verbose)
+                st.checkbox("Memory", value=self.memory, key=memory_key, on_change=self.update_memory)
+                st.checkbox("Cache", value=self.cache, key=cache_key, on_change=self.update_cache)
+                st.checkbox("Planning", value=self.planning, key=planning_key, on_change=self.update_planning)
+                st.number_input("Max req/min", value=self.max_rpm, key=max_rpm_key, on_change=self.update_max_rpm)    
+                st.button("Save", on_click=self.set_editable, args=(False,), key=rnd_id())
+        else:
+            fix_columns_width()
+            expander_title = f"Crew: {self.name}" if self.is_valid() else f"❗ Crew: {self.name}"
+            with st.expander(expander_title, expanded=expanded):
+                st.markdown(f"**Process:** {self.process}")
+                if self.process == Process.hierarchical:
+                    st.markdown(f"**Manager LLM:** {self.manager_llm}")
+                    st.markdown(f"**Manager Agent:** {self.manager_agent.role if self.manager_agent else 'None'}")
+                st.markdown(f"**Verbose:** {self.verbose}")
+                st.markdown(f"**Memory:** {self.memory}")
+                st.markdown(f"**Cache:** {self.cache}")
+                st.markdown(f"**Planning:** {self.planning}")
+                st.markdown(f"**Max req/min:** {self.max_rpm}")
+                st.markdown("**Tasks:**")
+                for i, task in enumerate([task for task in self.tasks if task.agent and task.agent.id in [agent.id for agent in self.agents]], 1):
+                    with st.container(border=True):
+                        async_tag = "(async)" if task.async_execution else ""
+                        st.markdown(f"**{i}.{async_tag}  {task.description}**")
+                        st.markdown(f"**Agent:** {task.agent.role if task.agent else 'None'}")
+                        tools_list = ", ".join([tool.name for tool in task.agent.tools]) if task.agent else "None"
+                        st.markdown(f" **Tools:** {tools_list}")
+                        st.markdown(f" **LLM:** {task.agent.llm_provider_model}")
+                if buttons:
+                    col1, col2 = st.columns(2)
+                    with col1:                    
+                        st.button("Edit", on_click=self.set_editable, key=rnd_id(), args=(True,))
+                    with col2:                   
+                        st.button("Delete", on_click=self.delete, key=rnd_id())
+                self.is_valid(show_warning=True)
+
+    def set_editable(self, edit):
+        self.edit = edit
+        db_utils.save_crew(self)

my_task.py

@@ -0,0 +1,90 @@
+from crewai import Task
+import streamlit as st
+from utils import rnd_id, fix_columns_width
+from streamlit import session_state as ss
+from db_utils import save_task, delete_task
+from datetime import datetime
+
+class MyTask:
+    def __init__(self, id=None, description=None, expected_output=None, agent=None, async_execution=None, created_at=None, context_from_async_tasks_ids=None, context_from_sync_tasks_ids=None, **kwargs):
+        self.id = id or "T_" + rnd_id()
+        self.description = description or "Identify the next big trend in AI. Focus on identifying pros and cons and the overall narrative."
+        self.expected_output = expected_output or "A comprehensive 3 paragraphs long report on the latest AI trends."
+        self.agent = agent or ss.agents[0] if ss.agents else None
+        self.async_execution = async_execution or False
+        self.context_from_async_tasks_ids = context_from_async_tasks_ids or None
+        self.context_from_sync_tasks_ids = context_from_sync_tasks_ids or None
+        self.created_at = created_at or datetime.now().isoformat()
+        self.edit_key = f'edit_{self.id}'
+        if self.edit_key not in ss:
+            ss[self.edit_key] = False
+
+    @property
+    def edit(self):
+        return ss[self.edit_key]
+
+    @edit.setter
+    def edit(self, value):
+        ss[self.edit_key] = value
+
+    def get_crewai_task(self, context_from_async_tasks=None, context_from_sync_tasks=None) -> Task:
+        context = []
+        if context_from_async_tasks:
+            context.extend(context_from_async_tasks)
+        if context_from_sync_tasks:
+            context.extend(context_from_sync_tasks)
+        
+        if context:
+            return Task(description=self.description, expected_output=self.expected_output, async_execution=self.async_execution, agent=self.agent.get_crewai_agent(), context=context)
+        else:
+            return Task(description=self.description, expected_output=self.expected_output, async_execution=self.async_execution, agent=self.agent.get_crewai_agent())
+
+    def delete(self):
+        ss.tasks = [task for task in ss.tasks if task.id != self.id]
+        delete_task(self.id)
+
+    def is_valid(self, show_warning=False):
+        if not self.agent:
+            if show_warning:
+                st.warning(f"Task {self.description} has no agent")
+            return False
+        if not self.agent.is_valid(show_warning):
+            return False
+        return True
+
+    def draw(self, key=None):
+        agent_options = [agent.role for agent in ss.agents]
+        expander_title = f"({self.agent.role if self.agent else 'unassigned'}) - {self.description}" if self.is_valid() else f"❗ ({self.agent.role if self.agent else 'unassigned'}) - {self.description}"
+        if self.edit:
+            with st.expander(expander_title, expanded=True):
+                with st.form(key=f'form_{self.id}' if key is None else key):
+                    self.description = st.text_area("Description", value=self.description)
+                    self.expected_output = st.text_area("Expected output", value=self.expected_output)
+                    self.agent = st.selectbox("Agent", options=ss.agents, format_func=lambda x: x.role, index=0 if self.agent is None else agent_options.index(self.agent.role))
+                    self.async_execution = st.checkbox("Async execution", value=self.async_execution)
+                    self.context_from_async_tasks_ids = st.multiselect("Context from async tasks", options=[task.id for task in ss.tasks if task.async_execution], default=self.context_from_async_tasks_ids, format_func=lambda x: [task.description[:120] for task in ss.tasks if task.id == x][0])
+                    self.context_from_sync_tasks_ids = st.multiselect("Context from sync tasks", options=[task.id for task in ss.tasks if not task.async_execution], default=self.context_from_sync_tasks_ids, format_func=lambda x: [task.description[:120] for task in ss.tasks if task.id == x][0])
+                    submitted = st.form_submit_button("Save")
+                    if submitted:
+                        self.set_editable(False)
+        else:
+            fix_columns_width()
+            with st.expander(expander_title):
+                st.markdown(f"**Description:** {self.description}")
+                st.markdown(f"**Expected output:** {self.expected_output}")
+                st.markdown(f"**Agent:** {self.agent.role if self.agent else 'None'}")
+                st.markdown(f"**Async execution:** {self.async_execution}")
+                st.markdown(f"**Context from async tasks:** {', '.join([task.description[:120] for task in ss.tasks if task.id in self.context_from_async_tasks_ids]) if self.context_from_async_tasks_ids else 'None'}")
+                st.markdown(f"**Context from sync tasks:** {', '.join([task.description[:120] for task in ss.tasks if task.id in self.context_from_sync_tasks_ids]) if self.context_from_sync_tasks_ids else 'None'}")
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.button("Edit", on_click=self.set_editable, args=(True,), key=rnd_id())
+                with col2:
+                    st.button("Delete", on_click=self.delete, key=rnd_id())
+                self.is_valid(show_warning=True)
+
+    def set_editable(self, edit):
+        self.edit = edit
+        save_task(self)
+        if not edit:
+            st.rerun()

my_tools.py

@@ -0,0 +1,368 @@
+import streamlit as st
+import os
+from utils import rnd_id
+from crewai_tools import CodeInterpreterTool,ScrapeElementFromWebsiteTool,TXTSearchTool,SeleniumScrapingTool,PGSearchTool,PDFSearchTool,MDXSearchTool,JSONSearchTool,GithubSearchTool,EXASearchTool,DOCXSearchTool,CSVSearchTool,ScrapeWebsiteTool, FileReadTool, DirectorySearchTool, DirectoryReadTool, CodeDocsSearchTool, YoutubeVideoSearchTool,SerperDevTool,YoutubeChannelSearchTool,WebsiteSearchTool
+from custom_tools import CustomApiTool,CustomFileWriteTool,CustomCodeInterpreterTool
+from langchain_community.tools import YahooFinanceNewsTool
+
+class MyTool:
+    def __init__(self, tool_id, name, description, parameters, **kwargs):
+        self.tool_id = tool_id or rnd_id()
+        self.name = name
+        self.description = description
+        self.parameters = kwargs
+        self.parameters_metadata = parameters
+
+    def create_tool(self):
+        pass
+
+    def get_parameters(self):
+        return self.parameters
+
+    def set_parameters(self, **kwargs):
+        self.parameters.update(kwargs)
+
+    def get_parameter_names(self):
+        return list(self.parameters_metadata.keys())
+
+    def is_parameter_mandatory(self, param_name):
+        return self.parameters_metadata.get(param_name, {}).get('mandatory', False)
+
+    def is_valid(self,show_warning=False):
+        for param_name, metadata in self.parameters_metadata.items():
+            if metadata['mandatory'] and not self.parameters.get(param_name):
+                if show_warning:
+                    st.warning(f"Parameter '{param_name}' is mandatory for tool '{self.name}'")
+                return False
+        return True
+
+class MyScrapeWebsiteTool(MyTool):
+    def __init__(self, tool_id=None, website_url=None):
+        parameters = {
+            'website_url': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'ScrapeWebsiteTool', "A tool that can be used to read website content.", parameters, website_url=website_url)
+
+    def create_tool(self) -> ScrapeWebsiteTool:
+        return ScrapeWebsiteTool(self.parameters.get('website_url') if self.parameters.get('website_url') else None)
+
+class MyFileReadTool(MyTool):
+    def __init__(self, tool_id=None, file_path=None):
+        parameters = {
+            'file_path': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'FileReadTool', "A tool that can be used to read a file's content.", parameters, file_path=file_path)
+
+    def create_tool(self) -> FileReadTool:
+        return FileReadTool(self.parameters.get('file_path') if self.parameters.get('file_path') else None)
+
+class MyDirectorySearchTool(MyTool):
+    def __init__(self, tool_id=None, directory=None):
+        parameters = {
+            'directory': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'DirectorySearchTool', "A tool that can be used to semantic search a query from a directory's content.", parameters, directory_path=directory)
+
+    def create_tool(self) -> DirectorySearchTool:
+        return DirectorySearchTool(self.parameters.get('directory') if self.parameters.get('directory') else None)
+
+class MyDirectoryReadTool(MyTool):
+    def __init__(self, tool_id=None, directory_contents=None):
+        parameters = {
+            'directory_contents': {'mandatory': True}
+        }
+        super().__init__(tool_id, 'DirectoryReadTool', "Use the tool to list the contents of the specified directory", parameters, directory_contents=directory_contents)
+
+    def create_tool(self) -> DirectoryReadTool:
+        return DirectoryReadTool(self.parameters.get('directory_contents'))
+
+class MyCodeDocsSearchTool(MyTool):
+    def __init__(self, tool_id=None, code_docs=None):
+        parameters = {
+            'code_docs': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'CodeDocsSearchTool', "A tool that can be used to search through code documentation.", parameters, code_docs=code_docs)
+
+    def create_tool(self) -> CodeDocsSearchTool:
+        return CodeDocsSearchTool(self.parameters.get('code_docs') if self.parameters.get('code_docs') else None)
+
+class MyYoutubeVideoSearchTool(MyTool):
+    def __init__(self, tool_id=None, youtube_video_url=None):
+        parameters = {
+            'youtube_video_url': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'YoutubeVideoSearchTool', "A tool that can be used to semantic search a query from a Youtube Video content.", parameters, youtube_video_url=youtube_video_url)
+
+    def create_tool(self) -> YoutubeVideoSearchTool:
+        return YoutubeVideoSearchTool(self.parameters.get('youtube_video_url') if self.parameters.get('youtube_video_url') else None)
+
+class MySerperDevTool(MyTool):
+    def __init__(self, tool_id=None, SERPER_API_KEY=None):
+        parameters = {
+            'SERPER_API_KEY': {'mandatory': True}
+        }
+
+        super().__init__(tool_id, 'SerperDevTool', "A tool that can be used to search the internet with a search_query", parameters)
+
+    def create_tool(self) -> SerperDevTool:
+        os.environ['SERPER_API_KEY'] = self.parameters.get('SERPER_API_KEY')
+        return SerperDevTool()
+    
+class MyYoutubeChannelSearchTool(MyTool):
+    def __init__(self, tool_id=None, youtube_channel_handle=None):
+        parameters = {
+            'youtube_channel_handle': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'YoutubeChannelSearchTool', "A tool that can be used to semantic search a query from a Youtube Channels content. Channel can be added as @channel", parameters, youtube_channel_handle=youtube_channel_handle)
+
+    def create_tool(self) -> YoutubeChannelSearchTool:
+        return YoutubeChannelSearchTool(self.parameters.get('youtube_channel_handle') if self.parameters.get('youtube_channel_handle') else None)
+
+class MyWebsiteSearchTool(MyTool):
+    def __init__(self, tool_id=None, website=None):
+        parameters = {
+            'website': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'WebsiteSearchTool', "A tool that can be used to semantic search a query from a specific URL content.", parameters, website=website)
+
+    def create_tool(self) -> WebsiteSearchTool:
+        return WebsiteSearchTool(self.parameters.get('website') if self.parameters.get('website') else None)
+   
+class MyCSVSearchTool(MyTool):
+    def __init__(self, tool_id=None, csv=None):
+        parameters = {
+            'csv': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'CSVSearchTool', "A tool that can be used to semantic search a query from a CSV's content.", parameters, csv=csv)
+
+    def create_tool(self) -> CSVSearchTool:
+        return CSVSearchTool(csv=self.parameters.get('csv') if self.parameters.get('csv') else None)
+
+class MyDocxSearchTool(MyTool):
+    def __init__(self, tool_id=None, docx=None):
+        parameters = {
+            'docx': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'DOCXSearchTool', "A tool that can be used to semantic search a query from a DOCX's content.", parameters, docx=docx)
+
+    def create_tool(self) -> DOCXSearchTool:
+        return DOCXSearchTool(docx=self.parameters.get('docx') if self.parameters.get('docx') else None)
+
+class MyEXASearchTool(MyTool):
+    def __init__(self, tool_id=None, EXA_API_KEY=None):
+        parameters = {
+            'EXA_API_KEY': {'mandatory': True}
+        }
+        super().__init__(tool_id, 'EXASearchTool', "A tool that can be used to search the internet from a search_query", parameters, EXA_API_KEY=EXA_API_KEY)
+
+    def create_tool(self) -> EXASearchTool:
+        os.environ['EXA_API_KEY'] = self.parameters.get('EXA_API_KEY')
+        return EXASearchTool()
+
+class MyGithubSearchTool(MyTool):
+    def __init__(self, tool_id=None, github_repo=None, gh_token=None, content_types=None):
+        parameters = {
+            'github_repo': {'mandatory': False},
+            'gh_token': {'mandatory': True},
+            'content_types': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'GithubSearchTool', "A tool that can be used to semantic search a query from a Github repository's content. Valid content_types: code,repo,pr,issue (comma sepparated)", parameters, github_repo=github_repo, gh_token=gh_token, content_types=content_types)
+
+    def create_tool(self) -> GithubSearchTool:
+        return GithubSearchTool(
+            github_repo=self.parameters.get('github_repo') if self.parameters.get('github_repo') else None,
+            gh_token=self.parameters.get('gh_token'),
+            content_types=self.parameters.get('search_query').split(",") if self.parameters.get('search_query') else ["code", "repo", "pr", "issue"]
+        )
+
+class MyJSONSearchTool(MyTool):
+    def __init__(self, tool_id=None, json_path=None):
+        parameters = {
+            'json_path': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'JSONSearchTool', "A tool that can be used to semantic search a query from a JSON's content.", parameters, json_path=json_path)
+
+    def create_tool(self) -> JSONSearchTool:
+        return JSONSearchTool(json_path=self.parameters.get('json_path') if self.parameters.get('json_path') else None)
+
+class MyMDXSearchTool(MyTool):
+    def __init__(self, tool_id=None, mdx=None):
+        parameters = {
+            'mdx': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'MDXSearchTool', "A tool that can be used to semantic search a query from a MDX's content.", parameters, mdx=mdx)
+
+    def create_tool(self) -> MDXSearchTool:
+        return MDXSearchTool(mdx=self.parameters.get('mdx') if self.parameters.get('mdx') else None)
+    
+class MyPDFSearchTool(MyTool):
+    def __init__(self, tool_id=None, pdf=None):
+        parameters = {
+            'pdf': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'PDFSearchTool', "A tool that can be used to semantic search a query from a PDF's content.", parameters, pdf=pdf)
+
+    def create_tool(self) -> PDFSearchTool:
+        return PDFSearchTool(self.parameters.get('pdf') if self.parameters.get('pdf') else None)
+
+class MyPGSearchTool(MyTool):
+    def __init__(self, tool_id=None, db_uri=None):
+        parameters = {
+            'db_uri': {'mandatory': True}
+        }
+        super().__init__(tool_id, 'PGSearchTool', "A tool that can be used to semantic search a query from a database table's content.", parameters, db_uri=db_uri)
+
+    def create_tool(self) -> PGSearchTool:
+        return PGSearchTool(self.parameters.get('db_uri'))
+
+class MySeleniumScrapingTool(MyTool):
+    def __init__(self, tool_id=None, website_url=None, css_element=None, cookie=None, wait_time=None):
+        parameters = {
+            'website_url': {'mandatory': False},
+            'css_element': {'mandatory': False},
+            'cookie': {'mandatory': False},
+            'wait_time': {'mandatory': False}
+        }
+        super().__init__(
+            tool_id, 
+            'SeleniumScrapingTool', 
+            "A tool that can be used to read a specific part of website content. CSS elements are separated by comma, cookies are in format {key1\:value1},{key2\:value2}", 
+            parameters, 
+            website_url=website_url, 
+            css_element=css_element, 
+            cookie=cookie, 
+            wait_time=wait_time
+)
+    def create_tool(self) -> SeleniumScrapingTool:
+        cookie_arrayofdicts = [{k: v} for k, v in (item.strip('{}').split(':') for item in self.parameters.get('cookie', '').split(','))] if self.parameters.get('cookie') else None
+
+        return SeleniumScrapingTool(
+            website_url=self.parameters.get('website_url') if self.parameters.get('website_url') else None,
+            css_element=self.parameters.get('css_element').split(',') if self.parameters.get('css_element') else None,
+            cookie=cookie_arrayofdicts,
+            wait_time=self.parameters.get('wait_time') if self.parameters.get('wait_time') else 10
+        )
+
+class MyTXTSearchTool(MyTool):
+    def __init__(self, tool_id=None, txt=None):
+        parameters = {
+            'txt': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'TXTSearchTool', "A tool that can be used to semantic search a query from a TXT's content.", parameters, txt=txt)
+
+    def create_tool(self) -> TXTSearchTool:
+        return TXTSearchTool(self.parameters.get('txt'))
+
+class MyScrapeElementFromWebsiteTool(MyTool):
+    def __init__(self, tool_id=None, website_url=None, css_element=None, cookie=None):
+        parameters = {
+            'website_url': {'mandatory': False},
+            'css_element': {'mandatory': False},
+            'cookie': {'mandatory': False}
+        }
+        super().__init__(
+            tool_id, 
+            'ScrapeElementFromWebsiteTool', 
+            "A tool that can be used to read a specific part of website content. CSS elements are separated by comma, cookies are in format {key1\:value1},{key2\:value2}", 
+            parameters, 
+            website_url=website_url, 
+            css_element=css_element, 
+            cookie=cookie
+        )
+
+    def create_tool(self) -> ScrapeElementFromWebsiteTool:
+        cookie_arrayofdicts = [{k: v} for k, v in (item.strip('{}').split(':') for item in self.parameters.get('cookie', '').split(','))] if self.parameters.get('cookie') else None
+        return ScrapeElementFromWebsiteTool(
+            website_url=self.parameters.get('website_url') if self.parameters.get('website_url') else None,
+            css_element=self.parameters.get('css_element').split(",") if self.parameters.get('css_element') else None,
+            cookie=cookie_arrayofdicts
+        )
+    
+class MyYahooFinanceNewsTool(MyTool):
+    def __init__(self, tool_id=None):
+        parameters = {}
+        super().__init__(tool_id, 'YahooFinanceNewsTool', "A tool that can be used to search Yahoo Finance News.", parameters)
+
+    def create_tool(self) -> YahooFinanceNewsTool:
+        return YahooFinanceNewsTool()
+    
+class MyCustomApiTool(MyTool):
+    def __init__(self, tool_id=None, base_url=None, headers=None, query_params=None):
+        parameters = {
+            'base_url': {'mandatory': False},
+            'headers': {'mandatory': False},
+            'query_params': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'CustomApiTool', "A tool that can be used to make API calls with customizable parameters.", parameters, base_url=base_url, headers=headers, query_params=query_params)
+
+    def create_tool(self) -> CustomApiTool:
+        return CustomApiTool(
+            base_url=self.parameters.get('base_url') if self.parameters.get('base_url') else None,
+            headers=eval(self.parameters.get('headers')) if self.parameters.get('headers') else None,
+            query_params=self.parameters.get('query_params') if self.parameters.get('query_params') else None
+        )
+
+class MyCustomFileWriteTool(MyTool):
+    def __init__(self, tool_id=None, base_folder=None, filename=None):
+        parameters = {
+            'base_folder': {'mandatory': True},
+            'filename': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'CustomFileWriteTool', "A tool that can be used to write a file to a specific folder.", parameters,base_folder=base_folder, filename=filename)
+
+    def create_tool(self) -> CustomFileWriteTool:
+        return CustomFileWriteTool(
+            base_folder=self.parameters.get('base_folder') if self.parameters.get('base_folder') else "workspace",
+            filename=self.parameters.get('filename') if self.parameters.get('filename') else None
+        )
+
+
+class MyCodeInterpreterTool(MyTool):
+    def __init__(self, tool_id=None):
+        parameters = {}
+        super().__init__(tool_id, 'CodeInterpreterTool', "This tool is used to give the Agent the ability to run code (Python3) from the code generated by the Agent itself. The code is executed in a sandboxed environment, so it is safe to run any code. Docker required.", parameters)
+
+    def create_tool(self) -> CodeInterpreterTool:
+        return CodeInterpreterTool()
+    
+
+class MyCustomCodeInterpreterTool(MyTool):
+    def __init__(self, tool_id=None,workspace_dir=None):
+        parameters = {
+            'workspace_dir': {'mandatory': False}
+        }
+        super().__init__(tool_id, 'CustomCodeInterpreterTool', "This tool is used to give the Agent the ability to run code (Python3) from the code generated by the Agent itself. The code is executed in a sandboxed environment, so it is safe to run any code. Worskpace folder is shared. Docker required.", parameters, workspace_dir=workspace_dir)
+
+    def create_tool(self) -> CustomCodeInterpreterTool:
+        return CustomCodeInterpreterTool(workspace_dir=self.parameters.get('workspace_dir') if self.parameters.get('workspace_dir') else "workspace")
+
+# Register all tools here
+TOOL_CLASSES = {
+    'SerperDevTool': MySerperDevTool,
+    'WebsiteSearchTool': MyWebsiteSearchTool,
+    'ScrapeWebsiteTool': MyScrapeWebsiteTool,
+    'SeleniumScrapingTool': MySeleniumScrapingTool,
+    'ScrapeElementFromWebsiteTool': MyScrapeElementFromWebsiteTool,
+    'CustomApiTool': MyCustomApiTool,
+    'CodeInterpreterTool': MyCodeInterpreterTool,
+    'CustomCodeInterpreterTool': MyCustomCodeInterpreterTool,
+    'FileReadTool': MyFileReadTool,
+    'CustomFileWriteTool': MyCustomFileWriteTool,
+    'DirectorySearchTool': MyDirectorySearchTool,
+    'DirectoryReadTool': MyDirectoryReadTool,
+
+    'YoutubeVideoSearchTool': MyYoutubeVideoSearchTool,
+    'YoutubeChannelSearchTool' :MyYoutubeChannelSearchTool,
+    'GithubSearchTool': MyGithubSearchTool,
+    'CodeDocsSearchTool': MyCodeDocsSearchTool,
+    'YahooFinanceNewsTool': MyYahooFinanceNewsTool,
+
+    'TXTSearchTool': MyTXTSearchTool,
+    'CSVSearchTool': MyCSVSearchTool,
+    'DOCXSearchTool': MyDocxSearchTool, 
+    'EXASearchTool': MyEXASearchTool,
+    'JSONSearchTool': MyJSONSearchTool,
+    'MDXSearchTool': MyMDXSearchTool,
+    'PDFSearchTool': MyPDFSearchTool,
+    'PGSearchTool': MyPGSearchTool    
+}

pg_agents.py

@@ -0,0 +1,80 @@
+import streamlit as st
+from streamlit import session_state as ss
+from my_agent import MyAgent
+import db_utils
+
+class PageAgents:
+    def __init__(self):
+        self.name = "Agents"
+
+    def create_agent(self, crew=None):
+        agent = MyAgent()
+        if 'agents' not in ss:
+            ss.agents = [MyAgent]
+        ss.agents.append(agent)
+        agent.edit = True
+        db_utils.save_agent(agent)  # Save agent to database
+
+        if crew:
+            crew.agents.append(agent)
+            db_utils.save_crew(crew)
+
+        return agent
+
+    def draw(self):
+        with st.container():
+            st.subheader(self.name)
+            editing = False
+            if 'agents' not in ss:
+                ss.agents = db_utils.load_agents()  # Load agents from database
+            if 'crews' not in ss:
+                ss.crews = db_utils.load_crews()  # Load crews from database
+
+            # Dictionary to track agent assignment
+            agent_assignment = {agent.id: [] for agent in ss.agents}
+
+            # Assign agents to crews
+            for crew in ss.crews:
+                for agent in crew.agents:
+                    agent_assignment[agent.id].append(crew.name)
+
+            # Display agents grouped by crew in tabs
+            tabs = ["All Agents"] + ["Unassigned Agents"] + [crew.name for crew in ss.crews]
+            tab_objects = st.tabs(tabs)
+
+            # Display all agents
+            with tab_objects[0]:
+                st.markdown("#### All Agents")
+                for agent in ss.agents:
+                    agent.draw()
+                    if agent.edit:
+                        editing = True
+                st.button('Create agent', on_click=self.create_agent, disabled=editing, key="create_agent_all")
+
+            # Display unassigned agents
+            with tab_objects[1]:
+                st.markdown("#### Unassigned Agents")
+                unassigned_agents = [agent for agent in ss.agents if not agent_assignment[agent.id]]
+                for agent in unassigned_agents:
+                    unique_key = f"{agent.id}_unassigned"
+                    agent.draw(key=unique_key)
+                    if agent.edit:
+                        editing = True
+                st.button('Create agent', on_click=self.create_agent, disabled=editing, key="create_agent_unassigned")
+
+            # Display agents grouped by crew
+            for i, crew in enumerate(ss.crews, 2):
+                with tab_objects[i]:
+                    st.markdown(f"#### {crew.name}")
+                    assigned_agents = [agent for agent in crew.agents]
+                    for agent in assigned_agents:
+                        unique_key = f"{agent.id}_{crew.name}"
+                        agent.draw(key=unique_key)
+                        if agent.edit:
+                            editing = True
+                    st.button('Create agent', on_click=self.create_agent, disabled=editing, kwargs={'crew': crew}, key=f"create_agent_{crew.name}")
+
+            if len(ss.agents) == 0:
+                st.write("No agents defined yet.")
+                st.button('Create agent', on_click=self.create_agent, disabled=editing)
+

pg_crew_run.py

@@ -0,0 +1,175 @@
+import re
+import streamlit as st
+from streamlit import session_state as ss
+import threading
+import ctypes
+import queue
+import time
+import traceback
+import os
+
+class PageCrewRun:
+    def __init__(self):
+        self.name = "Kickoff!"
+        self.maintain_session_state()
+
+    @staticmethod
+    def maintain_session_state():
+        defaults = {
+            'crew_thread': None,
+            'result': None,
+            'running': False,
+            'message_queue': queue.Queue(),
+            'selected_crew_name': None,
+            'placeholders': {}
+        }
+        for key, value in defaults.items():
+            if key not in ss:
+                ss[key] = value
+
+    @staticmethod
+    def extract_placeholders(text):
+        return re.findall(r'\{(.*?)\}', text)
+
+    def get_placeholders_from_crew(self, crew):
+        placeholders = set()
+        attributes = ['description', 'expected_output', 'role', 'backstory', 'goal']
+        
+        for task in crew.tasks:
+            placeholders.update(self.extract_placeholders(task.description))
+            placeholders.update(self.extract_placeholders(task.expected_output))
+        
+        for agent in crew.agents:
+            for attr in attributes[2:]:
+                placeholders.update(self.extract_placeholders(getattr(agent, attr)))
+        
+        return placeholders
+
+    def run_crew(self, crewai_crew, inputs, message_queue):
+        if (str(os.getenv('AGENTOPS_ENABLED')).lower() in ['true', '1']) and not ss.get('agentops_failed', False):
+            import agentops
+            agentops.start_session()
+        try:
+            result = crewai_crew.kickoff(inputs=inputs)
+            message_queue.put({"result": result})
+        except Exception as e:
+            if (str(os.getenv('AGENTOPS_ENABLED')).lower() in ['true', '1']) and not ss.get('agentops_failed', False):                       
+                agentops.end_session()
+            stack_trace = traceback.format_exc()
+            message_queue.put({"result": f"Error running crew: {str(e)}", "stack_trace": stack_trace})
+
+    def get_mycrew_by_name(self, crewname):
+        return next((crew for crew in ss.crews if crew.name == crewname), None)
+
+    def draw_placeholders(self, crew):
+        placeholders = self.get_placeholders_from_crew(crew)
+        if placeholders:
+            st.write('Placeholders to fill in:')
+            for placeholder in placeholders:
+                placeholder_key = f'placeholder_{placeholder}'
+                ss.placeholders[placeholder_key] = st.text_input(
+                    label=placeholder,
+                    key=placeholder_key,
+                    value=ss.placeholders.get(placeholder_key, ''),
+                    disabled=ss.running
+                )
+
+    def draw_crews(self):
+        if 'crews' not in ss or not ss.crews:
+            st.write("No crews defined yet.")
+            ss.selected_crew_name = None  # Reset selected crew name if there are no crews
+            return
+
+        # Check if the selected crew name still exists
+        if ss.selected_crew_name not in [crew.name for crew in ss.crews]:
+            ss.selected_crew_name = None
+
+        selected_crew_name = st.selectbox(
+            label="Select crew to run",
+            options=[crew.name for crew in ss.crews],
+            index=0 if ss.selected_crew_name is None else [crew.name for crew in ss.crews].index(ss.selected_crew_name) if ss.selected_crew_name in [crew.name for crew in ss.crews] else 0,
+            disabled=ss.running
+        )
+
+        if selected_crew_name != ss.selected_crew_name:
+            ss.selected_crew_name = selected_crew_name
+            st.rerun()
+
+        selected_crew = self.get_mycrew_by_name(ss.selected_crew_name)
+
+        if selected_crew:
+            selected_crew.draw(expanded=False,buttons=False)
+            self.draw_placeholders(selected_crew)
+            
+            if not selected_crew.is_valid(show_warning=True):
+                st.error("Selected crew is not valid. Please fix the issues.")
+            self.control_buttons(selected_crew)
+
+    def control_buttons(self, selected_crew):
+        if st.button('Run crew!', disabled=not selected_crew.is_valid() or ss.running):
+            inputs = {key.split('_')[1]: value for key, value in ss.placeholders.items()}
+            ss.result = None            
+            try:
+                crew = selected_crew.get_crewai_crew(full_output=True)
+            except Exception as e:
+                st.exception(e)
+                traceback.print_exc()
+                return
+
+            ss.running = True
+            ss.crew_thread = threading.Thread(
+                target=self.run_crew,
+                kwargs={
+                    "crewai_crew": crew,
+                    "inputs": inputs,
+                    "message_queue": ss.message_queue
+                }
+            )
+            ss.crew_thread.start()
+            ss.result = None
+            ss.running = True            
+            st.rerun()
+
+        if st.button('Stop crew!', disabled=not ss.running):
+            self.force_stop_thread(ss.crew_thread)
+            ss.message_queue.queue.clear()
+            ss.running = False
+            ss.crew_thread = None
+            ss.result = None
+            st.success("Crew stopped successfully.")
+            st.rerun()
+
+    def display_result(self):
+        if ss.result is not None:
+            if isinstance(ss.result, dict):
+                if 'final_output' in ss.result["result"]: #old version of crewai
+                    st.expander("Final output", expanded=True).write(ss.result["result"]['final_output'])
+                elif hasattr(ss.result["result"], 'raw'):  #new version of crewai
+                    st.expander("Final output", expanded=True).write(ss.result['result'].raw)  
+                st.expander("Full output", expanded=False).write(ss.result)
+            else:
+                st.error(ss.result)
+        elif ss.running and ss.crew_thread is not None:
+            with st.spinner("Running crew..."):
+                while ss.running:
+                    time.sleep(1)
+                    if not ss.message_queue.empty():
+                        ss.result = ss.message_queue.get()
+                        ss.running = False
+                        st.rerun()
+
+    @staticmethod
+    def force_stop_thread(thread):
+        if thread:
+            tid = ctypes.c_long(thread.ident)
+            if tid:
+                res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(SystemExit))
+                if res == 0:
+                    st.error("Nonexistent thread id")
+                else:
+                    st.success("Thread stopped successfully.")
+
+    def draw(self):
+        st.subheader(self.name)
+        self.draw_crews()
+        self.display_result()

pg_crews.py

@@ -0,0 +1,31 @@
+import streamlit as st
+from streamlit import session_state as ss
+from my_crew import MyCrew
+import db_utils
+
+class PageCrews:
+    def __init__(self):
+        self.name = "Crews"
+
+    def create_crew(self):
+        crew = MyCrew()
+        if 'crews' not in ss:
+            ss.crews = [MyCrew]
+        ss.crews.append(crew)
+        crew.edit = True
+        db_utils.save_crew(crew)  # Save crew to database
+        return crew
+
+    def draw(self):
+        with st.container():
+            st.subheader(self.name)
+            editing = False
+            if 'crews' not in ss:
+                ss.crews = db_utils.load_crews()  # Load crews from database
+            for crew in ss.crews:
+                crew.draw()
+                if crew.edit:
+                    editing = True
+            if len(ss.crews) == 0:
+                st.write("No crews defined yet.")
+            st.button('Create crew', on_click=self.create_crew, disabled=editing)

pg_export_crew.py

@@ -0,0 +1,528 @@
+import streamlit as st
+from streamlit import session_state as ss
+import zipfile
+import os
+import re
+import json
+import shutil
+import db_utils
+from utils import escape_quotes
+from my_tools import TOOL_CLASSES
+from crewai import Process
+from my_crew import MyCrew
+from my_agent import MyAgent
+from my_task import MyTask
+from datetime import datetime
+
+class PageExportCrew:
+    def __init__(self):
+        self.name = "Import/export"
+
+    def extract_placeholders(self, text):
+        return re.findall(r'\{(.*?)\}', text)
+
+    def get_placeholders_from_crew(self, crew):
+        placeholders = set()
+        for task in crew.tasks:
+            placeholders.update(self.extract_placeholders(task.description))
+            placeholders.update(self.extract_placeholders(task.expected_output))
+        return list(placeholders)
+
+    def generate_streamlit_app(self, crew, output_dir):
+        agents = crew.agents
+        tasks = crew.tasks
+
+        # Check if any custom tools are used
+        custom_tools_used = any(tool.name in ["CustomApiTool", "CustomFileWriteTool", "CustomCodeInterpreterTool"] 
+                                for agent in agents for tool in agent.tools)
+
+        def json_dumps_python(obj):
+            if isinstance(obj, bool):
+                return str(obj)
+            return json.dumps(obj)
+
+        def format_tool_instance(tool):
+            tool_class = TOOL_CLASSES.get(tool.name)
+            if tool_class:
+                params = ', '.join([f'{key}={json_dumps_python(value)}' for key, value in tool.parameters.items() if value is not None])
+                return f'{tool.name}({params})' if params else f'{tool.name}()'
+            return None
+
+        agent_definitions = ",\n        ".join([
+            f"""
+Agent(
+    role={json_dumps_python(agent.role)},
+    backstory={json_dumps_python(agent.backstory)},
+    goal={json_dumps_python(agent.goal)},
+    allow_delegation={json_dumps_python(agent.allow_delegation)},
+    verbose={json_dumps_python(agent.verbose)},
+    tools=[{', '.join([format_tool_instance(tool) for tool in agent.tools])}],
+    llm=create_llm({json_dumps_python(agent.llm_provider_model)}, {json_dumps_python(agent.temperature)})
+)
+            """
+            for agent in agents
+        ])
+
+        task_definitions = ",\n        ".join([
+            f"""
+Task(
+    description={json_dumps_python(task.description)},
+    expected_output={json_dumps_python(task.expected_output)},
+    agent=next(agent for agent in agents if agent.role == {json_dumps_python(task.agent.role)}),
+    async_execution={json_dumps_python(task.async_execution)}
+)
+            """
+            for task in tasks
+        ])
+
+        placeholders = self.get_placeholders_from_crew(crew)
+        placeholder_inputs = "\n    ".join([
+            f'{placeholder} = st.text_input({json_dumps_python(placeholder.capitalize())})'
+            for placeholder in placeholders
+        ])
+        placeholders_dict = ", ".join([f'{json_dumps_python(placeholder)}: {placeholder}' for placeholder in placeholders])
+
+        manager_llm_definition = ""
+        if crew.process == Process.hierarchical and crew.manager_llm:
+            manager_llm_definition = f'manager_llm=create_llm({json_dumps_python(crew.manager_llm)})'
+        elif crew.process == Process.hierarchical and crew.manager_agent:
+            manager_llm_definition = f'manager_agent=next(agent for agent in agents if agent.role == {json_dumps_python(crew.manager_agent.role)})'
+        
+        app_content = f"""
+import streamlit as st
+from crewai import Agent, Task, Crew, Process
+from langchain_openai import ChatOpenAI
+from langchain_groq import ChatGroq
+from langchain_anthropic import ChatAnthropic
+from dotenv import load_dotenv
+import os
+from crewai_tools import *
+{'''from custom_tools import CustomApiTool, CustomFileWriteTool, CustomCodeInterpreterTool''' if custom_tools_used else ''}
+
+load_dotenv()
+
+def create_lmstudio_llm(model, temperature):
+    api_base = os.getenv('LMSTUDIO_API_BASE')
+    os.environ["OPENAI_API_KEY"] = "lm-studio"
+    os.environ["OPENAI_API_BASE"] = api_base
+    if api_base:
+        return ChatOpenAI(openai_api_key='lm-studio', openai_api_base=api_base, temperature=temperature)
+    else:
+        raise ValueError("LM Studio API base not set in .env file")
+
+def create_openai_llm(model, temperature):
+    safe_pop_env_var('OPENAI_API_KEY')
+    safe_pop_env_var('OPENAI_API_BASE')
+    load_dotenv(override=True)
+    api_key = os.getenv('OPENAI_API_KEY')
+    api_base = os.getenv('OPENAI_API_BASE', 'https://api.openai.com/v1/')
+    if api_key:
+        return ChatOpenAI(openai_api_key=api_key, openai_api_base=api_base, model_name=model, temperature=temperature)
+    else:
+        raise ValueError("OpenAI API key not set in .env file")
+
+def create_groq_llm(model, temperature):
+    api_key = os.getenv('GROQ_API_KEY')
+    if api_key:
+        return ChatGroq(groq_api_key=api_key, model_name=model, temperature=temperature)
+    else:
+        raise ValueError("Groq API key not set in .env file")
+
+def create_anthropic_llm(model, temperature):
+    api_key = os.getenv('ANTHROPIC_API_KEY')
+    if api_key:
+        return ChatAnthropic(anthropic_api_key=api_key, model_name=model, temperature=temperature)
+    else:
+        raise ValueError("Anthropic API key not set in .env file")
+
+def safe_pop_env_var(key):
+    try:
+        os.environ.pop(key)
+    except KeyError:
+        pass
+        
+LLM_CONFIG = {{
+    "OpenAI": {{
+        "create_llm": create_openai_llm
+    }},
+    "Groq": {{
+        "create_llm": create_groq_llm
+    }},
+    "LM Studio": {{
+        "create_llm": create_lmstudio_llm
+    }},
+    "Anthropic": {{
+        "create_llm": create_anthropic_llm
+    }}
+}}
+
+def create_llm(provider_and_model, temperature=0.1):
+    provider, model = provider_and_model.split(": ")
+    create_llm_func = LLM_CONFIG.get(provider, {{}}).get("create_llm")
+    if create_llm_func:
+        return create_llm_func(model, temperature)
+    else:
+        raise ValueError(f"LLM provider {{provider}} is not recognized or not supported")
+
+def load_agents():
+    agents = [
+        {agent_definitions}
+    ]
+    return agents
+
+def load_tasks(agents):
+    tasks = [
+        {task_definitions}
+    ]
+    return tasks
+
+def main():
+    st.title({json_dumps_python(crew.name)})
+
+    agents = load_agents()
+    tasks = load_tasks(agents)
+    crew = Crew(
+        agents=agents, 
+        tasks=tasks, 
+        process={json_dumps_python(crew.process)}, 
+        verbose={json_dumps_python(crew.verbose)}, 
+        memory={json_dumps_python(crew.memory)}, 
+        cache={json_dumps_python(crew.cache)}, 
+        max_rpm={json_dumps_python(crew.max_rpm)},
+        {manager_llm_definition}
+    )
+
+    {placeholder_inputs}
+
+    placeholders = {{
+        {placeholders_dict}
+    }}
+
+    if st.button("Run Crew"):
+        with st.spinner("Running crew..."):
+            try:
+                result = crew.kickoff(inputs=placeholders)
+                if isinstance(result, dict):
+                    with st.expander("Final output", expanded=True):                
+                        st.write(result.get('final_output', 'No final output available'))
+                    with st.expander("Full output", expanded=False):
+                        st.write(result)
+                else:
+                    st.write("Result:")
+                    st.write(result)
+            except Exception as e:
+                st.error(f"An error occurred: {{str(e)}}")
+
+if __name__ == '__main__':
+    main()
+"""
+        with open(os.path.join(output_dir, 'app.py'), 'w') as f:
+            f.write(app_content)
+
+        # If custom tools are used, copy the custom_tools.py file
+        if custom_tools_used:
+            source_path = os.path.join(os.path.dirname(__file__), 'custom_tools.py')
+            dest_path = os.path.join(output_dir, 'custom_tools.py')
+            shutil.copy2(source_path, dest_path)
+
+    def create_env_file(self, output_dir):
+        env_content = """
+# OPENAI_API_KEY="FILL-IN-YOUR-OPENAI-API-KEY"
+# OPENAI_API_BASE="OPTIONAL-FILL-IN-YOUR-OPENAI-API-BASE"
+# GROQ_API_KEY="FILL-IN-YOUR-GROQ-API-KEY"
+# ANTHROPIC_API_KEY="FILL-IN-YOUR-ANTHROPIC-API-KEY"
+# LMSTUDIO_API_BASE="http://localhost:1234/v1"
+"""
+        with open(os.path.join(output_dir, '.env'), 'w') as f:
+            f.write(env_content)
+
+    def create_shell_scripts(self, output_dir):
+        install_sh_content = """
+#!/bin/bash
+
+# Create a virtual environment
+python -m venv venv || { echo "Failed to create venv"; exit 1; }
+
+# Activate the virtual environment
+source venv/bin/activate || { echo "Failed to activate venv"; exit 1; }
+
+# Install requirements
+pip install -r requirements.txt || { echo "Failed to install requirements"; exit 1; }
+
+echo "Installation completed successfully."
+"""
+        with open(os.path.join(output_dir, 'install.sh'), 'w') as f:
+            f.write(install_sh_content)
+            os.chmod(os.path.join(output_dir, 'install.sh'), 0o755)
+
+        run_sh_content = """
+#!/bin/bash
+
+# Get the directory where the script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+# Activate the virtual environment
+source "$SCRIPT_DIR/venv/bin/activate" || { echo "Failed to activate venv"; exit 1; }
+
+cd "$SCRIPT_DIR"
+
+streamlit run app.py --server.headless True
+"""
+        with open(os.path.join(output_dir, 'run.sh'), 'w') as f:
+            f.write(run_sh_content)
+            os.chmod(os.path.join(output_dir, 'run.sh'), 0o755)
+
+        install_bat_content = """
+@echo off
+
+:: Create a virtual environment
+python -m venv venv || (
+    echo Failed to create venv
+    exit /b 1
+)
+
+:: Activate the virtual environment
+call venv\\Scripts\\activate || (
+    echo Failed to activate venv
+    exit /b 1
+)
+
+:: Install requirements
+pip install -r requirements.txt || (
+    echo Failed to install requirements
+    exit /b 1
+)
+
+echo Installation completed successfully.
+"""
+        with open(os.path.join(output_dir, 'install.bat'), 'w') as f:
+            f.write(install_bat_content)
+
+        run_bat_content = """
+@echo off
+
+:: Activate the virtual environment
+call venv\\Scripts\\activate || (
+    echo Failed to activate venv
+    exit /b 1
+)
+
+:: Run the Streamlit app
+streamlit run app.py --server.headless true
+"""
+        with open(os.path.join(output_dir, 'run.bat'), 'w') as f:
+            f.write(run_bat_content)
+
+        # Copy the main project's requirements.txt
+        source_requirements = os.path.join(os.path.dirname(__file__), '..', 'requirements.txt')
+        dest_requirements = os.path.join(output_dir, 'requirements.txt')
+        shutil.copy2(source_requirements, dest_requirements)
+
+    def zip_directory(self, folder_path, output_path):
+        with zipfile.ZipFile(output_path, 'w') as zip_file:
+            for foldername, subfolders, filenames in os.walk(folder_path):
+                for filename in filenames:
+                    file_path = os.path.join(foldername, filename)
+                    arcname = os.path.relpath(file_path, folder_path)
+                    zip_file.write(file_path, arcname)
+
+    def create_export(self, crew_name):
+        output_dir = f"{crew_name}_app"
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        selected_crew = next((crew for crew in ss.crews if crew.name == crew_name), None)
+        if selected_crew:
+            self.generate_streamlit_app(selected_crew, output_dir)
+            self.create_env_file(output_dir)
+            self.create_shell_scripts(output_dir)
+
+            zip_path = f"{crew_name}_app.zip"
+            self.zip_directory(output_dir, zip_path)
+            return zip_path
+
+    def export_crew_to_json(self, crew):
+        crew_data = {
+            'id': crew.id,
+            'name': crew.name,
+            'process': crew.process,
+            'verbose': crew.verbose,
+            'memory': crew.memory,
+            'cache': crew.cache,
+            'max_rpm': crew.max_rpm,
+            'manager_llm': crew.manager_llm,
+            'manager_agent': crew.manager_agent.id if crew.manager_agent else None,
+            'created_at': crew.created_at,
+            'agents': [],
+            'tasks': [],
+            'tools': []
+        }
+
+        tool_ids = set()
+
+        for agent in crew.agents:
+            agent_data = {
+                'id': agent.id,
+                'role': agent.role,
+                'backstory': agent.backstory,
+                'goal': agent.goal,
+                'allow_delegation': agent.allow_delegation,
+                'verbose': agent.verbose,
+                'cache': agent.cache,
+                'llm_provider_model': agent.llm_provider_model,
+                'temperature': agent.temperature,
+                'max_iter': agent.max_iter,
+                'tool_ids': [tool.tool_id for tool in agent.tools]
+            }
+            crew_data['agents'].append(agent_data)
+            tool_ids.update(agent_data['tool_ids'])
+
+        for task in crew.tasks:
+            task_data = {
+                'id': task.id,
+                'description': task.description,
+                'expected_output': task.expected_output,
+                'async_execution': task.async_execution,
+                'agent_id': task.agent.id if task.agent else None,
+                'context_from_async_tasks_ids': task.context_from_async_tasks_ids,
+                'created_at': task.created_at
+            }
+            crew_data['tasks'].append(task_data)
+
+        for tool_id in tool_ids:
+            tool = next((t for t in ss.tools if t.tool_id == tool_id), None)
+            if tool:
+                tool_data = {
+                    'tool_id': tool.tool_id,
+                    'name': tool.name,
+                    'description': tool.description,
+                    'parameters': tool.get_parameters()
+                }
+                crew_data['tools'].append(tool_data)
+
+        return json.dumps(crew_data, indent=2)
+    
+    def import_crew_from_json(self, crew_data):
+        # Create tools
+        for tool_data in crew_data['tools']:
+            tool_class = TOOL_CLASSES[tool_data['name']]
+            tool = tool_class(tool_id=tool_data['tool_id'])
+            tool.set_parameters(**tool_data['parameters'])
+            if tool not in ss.tools:
+                ss.tools.append(tool)
+                db_utils.save_tool(tool)
+
+        # Create agents
+        agents = []
+        for agent_data in crew_data['agents']:
+            agent = MyAgent(
+                id=agent_data['id'],
+                role=agent_data['role'],
+                backstory=agent_data['backstory'],
+                goal=agent_data['goal'],
+                allow_delegation=agent_data['allow_delegation'],
+                verbose=agent_data['verbose'],
+                cache=agent_data.get('cache', True),
+                llm_provider_model=agent_data['llm_provider_model'],
+                temperature=agent_data['temperature'],
+                max_iter=agent_data['max_iter'],
+                created_at=agent_data.get('created_at')
+            )
+            agent.tools = [next(tool for tool in ss.tools if tool.tool_id == tool_id) for tool_id in agent_data['tool_ids']]
+            agents.append(agent)
+            db_utils.save_agent(agent)
+
+        # Create tasks
+        tasks = []
+        for task_data in crew_data['tasks']:
+            task = MyTask(
+                id=task_data['id'],
+                description=task_data['description'],
+                expected_output=task_data['expected_output'],
+                async_execution=task_data['async_execution'],
+                agent=next((agent for agent in agents if agent.id == task_data['agent_id']), None),
+                context_from_async_tasks_ids=task_data['context_from_async_tasks_ids'],
+                created_at=task_data['created_at']
+            )
+            tasks.append(task)
+            db_utils.save_task(task)
+
+        # Create crew
+        crew = MyCrew(
+            id=crew_data['id'],
+            name=crew_data['name'],
+            process=crew_data['process'],
+            verbose=crew_data['verbose'],
+            memory=crew_data['memory'],
+            cache=crew_data['cache'],
+            max_rpm=crew_data['max_rpm'],
+            manager_llm=crew_data['manager_llm'],
+            manager_agent=next((agent for agent in agents if agent.id == crew_data['manager_agent']), None),
+            created_at=crew_data['created_at']
+        )
+        crew.agents = agents
+        crew.tasks = tasks
+        db_utils.save_crew(crew)
+
+        if crew not in ss.crews:
+            ss.crews.append(crew)
+
+        return crew
+
+    def draw(self):
+        st.subheader(self.name)
+
+        # Full JSON Export Button
+        if st.button("Export everything to json"):
+            current_datetime = datetime.now().strftime("%Y%m%d_%H%M%S")
+            file_path = f"all_crews_{current_datetime}.json"
+            db_utils.export_to_json(file_path)
+            with open(file_path, "rb") as fp:
+                st.download_button(
+                    label="Download All Crews JSON",
+                    data=fp,
+                    file_name=file_path,
+                    mime="application/json"
+                )
+
+        # JSON Import Button
+        uploaded_file = st.file_uploader("Import JSON file", type="json")
+        if uploaded_file is not None:
+            json_data = json.load(uploaded_file)
+            
+            if isinstance(json_data, list):  # Full database export
+                with open("uploaded_file.json", "w") as f:
+                    json.dump(json_data, f)
+                db_utils.import_from_json("uploaded_file.json")
+                st.success("Full database JSON file imported successfully!")
+            elif isinstance(json_data, dict) and 'id' in json_data:  # Single crew export
+                imported_crew = self.import_crew_from_json(json_data)
+                st.success(f"Crew '{imported_crew.name}' imported successfully!")
+            else:
+                st.error("Invalid JSON format. Please upload a valid crew or full database export file.")
+
+        if 'crews' not in ss or len(ss.crews) == 0:
+            st.write("No crews defined yet.")
+        else:
+            crew_names = [crew.name for crew in ss.crews]
+            selected_crew_name = st.selectbox("Select crew to export", crew_names)
+            
+            if st.button("Export singlepage app"):
+                zip_path = self.create_export(selected_crew_name)
+                with open(zip_path, "rb") as fp:
+                    st.download_button(
+                        label="Download Exported App",
+                        data=fp,
+                        file_name=f"{selected_crew_name}_app.zip",
+                        mime="application/zip"
+                    )        
+            if st.button("Export crew to JSON"):
+                selected_crew = next((crew for crew in ss.crews if crew.name == selected_crew_name), None)
+                if selected_crew:
+                    crew_json = self.export_crew_to_json(selected_crew)
+                    st.download_button(
+                        label="Download Crew JSON",
+                        data=crew_json,
+                        file_name=f"{selected_crew_name}_export.json",
+                        mime="application/json"
+                    )

pg_tasks.py

@@ -0,0 +1,81 @@
+import streamlit as st
+from streamlit import session_state as ss
+from my_task import MyTask
+import db_utils
+
+class PageTasks:
+    def __init__(self):
+        self.name = "Tasks"
+
+    def create_task(self, crew=None):
+        task = MyTask()   
+        if 'tasks' not in ss:
+            ss.tasks = [MyTask]
+        ss.tasks.append(task)
+        task.edit = True                
+        db_utils.save_task(task)  # Save task to database
+
+        if crew:
+            crew.tasks.append(task)
+            db_utils.save_crew(crew)
+
+        return task
+
+    def draw(self):
+        with st.container():
+            st.subheader(self.name)
+            editing = False
+            if 'tasks' not in ss:
+                ss.tasks = db_utils.load_tasks()  # Load tasks from database
+            if 'crews' not in ss:
+                ss.crews = db_utils.load_crews()  # Load crews from database
+
+            # Dictionary to track task assignment
+            task_assignment = {task.id: [] for task in ss.tasks}
+
+            # Assign tasks to crews
+            for crew in ss.crews:
+                for task in crew.tasks:
+                    task_assignment[task.id].append(crew.name)
+
+            # Display tasks grouped by crew in tabs
+            tabs = ["All Tasks"] + ["Unassigned Tasks"] + [crew.name for crew in ss.crews]
+            tab_objects = st.tabs(tabs)
+
+            # Display all tasks
+            with tab_objects[0]:
+                st.markdown("#### All Tasks")
+                for task in ss.tasks:
+                    task.draw()
+                    if task.edit:
+                        editing = True
+                st.button('Create task', on_click=self.create_task, disabled=editing, key="create_task_all")
+
+            # Display unassigned tasks
+            with tab_objects[1]:
+                st.markdown("#### Unassigned Tasks")
+                unassigned_tasks = [task for task in ss.tasks if not task_assignment[task.id]]
+                for task in unassigned_tasks:
+                    unique_key = f"{task.id}_unasigned"
+                    task.draw(key=unique_key)
+                    if task.edit:
+                        editing = True
+                st.button('Create task', on_click=self.create_task, disabled=editing, key="create_task_unassigned")
+
+            # Display tasks grouped by crew
+            for i, crew in enumerate(ss.crews, 2):
+                with tab_objects[i]:
+                    st.markdown(f"#### {crew.name}")
+                    assigned_tasks = [task for task in crew.tasks]
+                    for task in assigned_tasks:
+                        unique_key = f"{task.id}_{crew.name}"
+                        task.draw(key=unique_key)
+                        if task.edit:
+                            editing = True
+                    st.button('Create task', on_click=self.create_task, disabled=editing,kwargs={'crew': crew}, key=f"create_task_{crew.name}")
+
+
+            if len(ss.tasks) == 0:
+                st.write("No tasks defined yet.")
+                st.button('Create task', on_click=self.create_task, disabled=editing)
+

pg_tools.py

@@ -0,0 +1,69 @@
+import streamlit as st
+from utils import rnd_id
+from my_tools import TOOL_CLASSES
+from streamlit import session_state as ss
+import db_utils
+
+class PageTools:
+    def __init__(self):
+        self.name = "Tools"
+        self.available_tools = TOOL_CLASSES
+
+    def create_tool(self, tool_name):
+        tool_class = self.available_tools[tool_name]
+        tool_instance = tool_class(rnd_id())
+        if 'tools' not in ss:
+            ss.tools = []
+        ss.tools.append(tool_instance)
+        db_utils.save_tool(tool_instance)  # Save tool to database
+
+    def remove_tool(self, tool_id):
+        ss.tools = [tool for tool in ss.tools if tool.tool_id != tool_id]
+        db_utils.delete_tool(tool_id)
+        st.rerun()
+
+    def set_tool_parameter(self, tool_id, param_name, value):
+        if value == "":
+            value = None
+        for tool in ss.tools:
+            if tool.tool_id == tool_id:
+                tool.set_parameters(**{param_name: value})
+                db_utils.save_tool(tool)
+                break
+
+    def get_tool_display_name(self, tool):
+        first_param_name = tool.get_parameter_names()[0] if tool.get_parameter_names() else None
+        first_param_value = tool.parameters.get(first_param_name, '') if first_param_name else ''
+        return f"{tool.name} ({first_param_value if first_param_value else tool.tool_id})"
+
+    def draw_tools(self):
+        c1,c2 = st.columns([1, 3])
+        #st.write("Available Tools:")
+        with c1:
+            for tool_name in self.available_tools.keys():
+                tool_class = self.available_tools[tool_name]
+                tool_instance = tool_class()
+                tool_description = tool_instance.description
+                if st.button(f"{tool_name}", key=f"enable_{tool_name}", help=tool_description):
+                    self.create_tool(tool_name)
+        with c2:
+            if 'tools' in ss:
+                st.write("##### Enabled Tools")
+                for tool in ss.tools:
+                    display_name = self.get_tool_display_name(tool)
+                    is_complete = tool.is_valid()
+                    expander_title = display_name if is_complete else f"❗ {display_name}"
+                    with st.expander(expander_title):
+                        st.write(tool.description)
+                        for param_name in tool.get_parameter_names():
+                            param_value = tool.parameters.get(param_name, "")
+                            placeholder = "Required" if tool.is_parameter_mandatory(param_name) else "Optional"
+                            new_value = st.text_input(f"{param_name}", value=param_value, key=f"{tool.tool_id}_{param_name}", placeholder=placeholder)
+                            if new_value != param_value:
+                                self.set_tool_parameter(tool.tool_id, param_name, new_value)
+                        if st.button(f"Remove", key=f"remove_{tool.tool_id}"):
+                            self.remove_tool(tool.tool_id)
+
+    def draw(self):
+        st.subheader(self.name)
+        self.draw_tools()

utils.py

@@ -0,0 +1,24 @@
+import random
+import string
+from streamlit import markdown
+
+def rnd_id(length=8):
+    characters = string.ascii_letters + string.digits
+    random_text = ''.join(random.choice(characters) for _ in range(length))
+    return random_text
+
+def escape_quotes(s):
+    return s.replace('"', '\\"').replace("'", "\\'")
+
+def fix_columns_width():
+    markdown("""
+            <style>
+                div[data-testid="column"] {
+                    width: fit-content !important;
+                    flex: unset;
+                }
+                div[data-testid="column"] * {
+                    width: fit-content !important;
+                }
+            </style>
+            """, unsafe_allow_html=True)