Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,33 @@
+OPENAI_API_KEY="your_openai_api_key_here"
+GOOGLE_API_KEY=""
+ANTHROPIC_API_KEY=""
+
+WOLFRAM_ALPHA_APPID="your_wolfram_alpha_appid_here"
+ZAPIER_NLA_API_KEY="your_zapier_nla_api_key_here"
+
+EVAL_PORT=8000
+MODEL_NAME="gpt-4"
+CELERY_BROKER_URL="redis://localhost:6379"
+
+SERVER="http://localhost:8000"
+USE_GPU=True
+PLAYGROUND_DIR="playground"
+
+LOG_LEVEL="INFO"
+BOT_NAME="Orca"
+
+WINEDB_HOST="your_winedb_host_here"
+WINEDB_PASSWORD="your_winedb_password_here"
+BING_SEARCH_URL="your_bing_search_url_here"
+
+BING_SUBSCRIPTION_KEY="your_bing_subscription_key_here"
+SERPAPI_API_KEY="your_serpapi_api_key_here"
+IFTTTKey="your_iftttkey_here"
+
+BRAVE_API_KEY="your_brave_api_key_here"
+SPOONACULAR_KEY="your_spoonacular_key_here"
+HF_API_KEY="your_huggingface_api_key_here"
+
+
+REDIS_HOST=
+REDIS_PORT=

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/Agora-Banner-blend.png filter=lfs diff=lfs merge=lfs -text
+images/swarms_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+swarms/agents/models/segment_anything/assets/masks1.png filter=lfs diff=lfs merge=lfs -text
+swarms/agents/models/segment_anything/assets/minidemo.gif filter=lfs diff=lfs merge=lfs -text
+swarms/agents/models/segment_anything/assets/notebook2.png filter=lfs diff=lfs merge=lfs -text

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [kyegomez]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: #Nothing

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] "
+labels: bug
+assignees: kyegomez
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: 'kyegomez'
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.yml

@@ -0,0 +1,25 @@
+<!-- Thank you for contributing to Swarms!
+
+Replace this comment with:
+  - Description: a description of the change, 
+  - Issue: the issue # it fixes (if applicable),
+  - Dependencies: any dependencies required for this change,
+  - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
+  - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
+
+If you're adding a new integration, please include:
+  1. a test for the integration, preferably unit tests that do not rely on network access,
+  2. an example notebook showing its use.
+
+Maintainer responsibilities:
+  - General / Misc / if you don't know who to tag: kye@apac.ai
+  - DataLoaders / VectorStores / Retrievers: kye@apac.ai
+  - Models / Prompts: kye@apac.ai
+  - Memory: kye@apac.ai
+  - Agents / Tools / Toolkits: kye@apac.ai
+  - Tracing / Callbacks: kye@apac.ai
+  - Async: kye@apac.ai
+
+If no one reviews your PR within a few days, feel free to kye@apac.ai
+
+See contribution guidelines for more information on how to write/run tests, lint, etc: https://github.com/kyegomez/swarms

.github/dependabot.yml

@@ -0,0 +1,14 @@
+# https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+

.github/workflows/label.yml

@@ -0,0 +1,22 @@
+# This workflow will triage pull requests and apply a label based on the
+# paths that are modified in the pull request.
+#
+# To use this workflow, you will need to set up a .github/labeler.yml
+# file with configuration.  For more information, see:
+# https://github.com/actions/labeler
+
+name: Labeler
+on: [pull_request_target]
+
+jobs:
+  label:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+    - uses: actions/labeler@v4
+      with:
+        repo-token: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/pylint.yml

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')

.github/workflows/python-publish.yml

@@ -0,0 +1,32 @@
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@f8c70e705ffc13c3b4d1221169b84f12a75d6ca8
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/quality.yml

@@ -0,0 +1,23 @@
+name: Quality
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout actions
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Init environment 
+        uses: ./.github/actions/init-environment 
+      - name: Run linter
+        run: |
+          pylint `git diff --name-only --diff-filter=d origin/main HEAD | grep -E '\.py$' | tr '\n' ' '`

.github/workflows/ruff.yml

@@ -0,0 +1,8 @@
+name: Ruff
+on: [ push, pull_request ]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: chartboost/ruff-action@v1

.github/workflows/run_test.yml

@@ -0,0 +1,23 @@
+name: Python application test
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.8
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Run tests with pytest
+      run: |
+        pytest tests/

.github/workflows/stale.yml

@@ -0,0 +1,27 @@
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '26 12 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v8
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Stale issue message'
+        stale-pr-message: 'Stale pull request message'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

.github/workflows/test.yml

@@ -0,0 +1,49 @@
+name: test
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_dispatch:
+
+env:
+  POETRY_VERSION: "1.4.2"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+        test_type:
+          - "core"
+          - "extended"
+    name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: "1.4.2"
+          cache-key: ${{ matrix.test_type }}
+          install-command: |
+              if [ "${{ matrix.test_type }}" == "core" ]; then
+                echo "Running core tests, installing dependencies with poetry..."
+                poetry install
+              else
+                echo "Running extended tests, installing dependencies with poetry..."
+                poetry install -E extended_testing
+              fi
+      - name: Run ${{matrix.test_type}} tests
+        run: |
+          if [ "${{ matrix.test_type }}" == "core" ]; then
+            make test
+          else
+            make extended_tests
+          fi
+        shell: bash

.github/workflows/unit-test.yml

@@ -0,0 +1,45 @@
+name: build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+
+    - name: Install dependencies
+      run: pip install -r requirements.txt
+
+    - name: Run Python unit tests
+      run: python3 -m unittest tests/swarms
+
+    - name: Verify that the Docker image for the action builds
+      run: docker build . --file Dockerfile
+
+    - name: Integration test 1
+      uses: ./
+      with:
+        input-one: something
+        input-two: true
+
+    - name: Integration test 2
+      uses: ./
+      with:
+        input-one: something else
+        input-two: false
+
+    - name: Verify integration test results
+      run: python3 -m unittest unittesting/swarms

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - discord-bot
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,182 @@
+__pycache__/
+.venv/
+
+.env
+
+image/
+audio/
+video/
+dataframe/
+
+static/generated
+swarms/__pycache__
+venv
+.DS_Store
+
+.DS_STORE
+swarms/agents/.DS_Store
+
+_build
+
+
+.DS_STORE
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+.DS_Store
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.readthedocs.yml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+mkdocs:
+  configuration: mkdocs.yml
+
+python:
+   install:
+   - requirements: requirements.txt

=3.38.0

@@ -0,0 +1,64 @@
+Defaulting to user installation because normal site-packages is not writeable
+Requirement already satisfied: gradio_client in /home/zack/.local/lib/python3.10/site-packages (0.2.5)
+Requirement already satisfied: gradio in /home/zack/.local/lib/python3.10/site-packages (3.33.1)
+Requirement already satisfied: fsspec in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (2023.5.0)
+Requirement already satisfied: httpx in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (0.24.1)
+Requirement already satisfied: huggingface-hub>=0.13.0 in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (0.16.4)
+Requirement already satisfied: packaging in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (23.2)
+Requirement already satisfied: requests in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (2.27.1)
+Requirement already satisfied: typing-extensions in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (4.8.0)
+Requirement already satisfied: websockets in /home/zack/.local/lib/python3.10/site-packages (from gradio_client) (11.0.3)
+Requirement already satisfied: aiofiles in /home/zack/.local/lib/python3.10/site-packages (from gradio) (23.1.0)
+Requirement already satisfied: aiohttp in /home/zack/.local/lib/python3.10/site-packages (from gradio) (3.8.4)
+Requirement already satisfied: altair>=4.2.0 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (4.2.2)
+Requirement already satisfied: fastapi in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.100.1)
+Requirement already satisfied: ffmpy in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.3.0)
+Requirement already satisfied: jinja2 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (3.1.2)
+Requirement already satisfied: markdown-it-py[linkify]>=2.0.0 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (2.2.0)
+Requirement already satisfied: markupsafe in /home/zack/.local/lib/python3.10/site-packages (from gradio) (2.1.3)
+Requirement already satisfied: matplotlib in /home/zack/.local/lib/python3.10/site-packages (from gradio) (3.1.3)
+Requirement already satisfied: mdit-py-plugins<=0.3.3 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.3.3)
+Requirement already satisfied: numpy in /home/zack/.local/lib/python3.10/site-packages (from gradio) (1.22.4)
+Requirement already satisfied: orjson in /home/zack/.local/lib/python3.10/site-packages (from gradio) (3.9.7)
+Requirement already satisfied: pandas in /home/zack/.local/lib/python3.10/site-packages (from gradio) (1.4.2)
+Requirement already satisfied: pillow in /home/zack/.local/lib/python3.10/site-packages (from gradio) (9.5.0)
+Requirement already satisfied: pydantic in /home/zack/.local/lib/python3.10/site-packages (from gradio) (1.8.2)
+Requirement already satisfied: pydub in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.25.1)
+Requirement already satisfied: pygments>=2.12.0 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (2.16.1)
+Requirement already satisfied: python-multipart in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.0.6)
+Requirement already satisfied: pyyaml in /home/zack/.local/lib/python3.10/site-packages (from gradio) (6.0)
+Requirement already satisfied: semantic-version in /home/zack/.local/lib/python3.10/site-packages (from gradio) (2.10.0)
+Requirement already satisfied: uvicorn>=0.14.0 in /home/zack/.local/lib/python3.10/site-packages (from gradio) (0.18.3)
+Requirement already satisfied: entrypoints in /home/zack/.local/lib/python3.10/site-packages (from altair>=4.2.0->gradio) (0.4)
+Requirement already satisfied: jsonschema>=3.0 in /home/zack/.local/lib/python3.10/site-packages (from altair>=4.2.0->gradio) (4.19.1)
+Requirement already satisfied: toolz in /home/zack/.local/lib/python3.10/site-packages (from altair>=4.2.0->gradio) (0.12.0)
+Requirement already satisfied: filelock in /home/zack/.local/lib/python3.10/site-packages (from huggingface-hub>=0.13.0->gradio_client) (3.12.4)
+Requirement already satisfied: tqdm>=4.42.1 in /home/zack/.local/lib/python3.10/site-packages (from huggingface-hub>=0.13.0->gradio_client) (4.64.0)
+Requirement already satisfied: mdurl~=0.1 in /home/zack/.local/lib/python3.10/site-packages (from markdown-it-py[linkify]>=2.0.0->gradio) (0.1.2)
+Requirement already satisfied: linkify-it-py<3,>=1 in /home/zack/.local/lib/python3.10/site-packages (from markdown-it-py[linkify]>=2.0.0->gradio) (2.0.2)
+Requirement already satisfied: python-dateutil>=2.8.1 in /home/zack/.local/lib/python3.10/site-packages (from pandas->gradio) (2.8.2)
+Requirement already satisfied: pytz>=2020.1 in /usr/lib/python3/dist-packages (from pandas->gradio) (2022.1)
+Requirement already satisfied: click>=7.0 in /home/zack/.local/lib/python3.10/site-packages (from uvicorn>=0.14.0->gradio) (8.1.6)
+Requirement already satisfied: h11>=0.8 in /home/zack/.local/lib/python3.10/site-packages (from uvicorn>=0.14.0->gradio) (0.14.0)
+Requirement already satisfied: attrs>=17.3.0 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (23.1.0)
+Requirement already satisfied: charset-normalizer<4.0,>=2.0 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (2.0.12)
+Requirement already satisfied: multidict<7.0,>=4.5 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (6.0.4)
+Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (4.0.2)
+Requirement already satisfied: yarl<2.0,>=1.0 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (1.9.2)
+Requirement already satisfied: frozenlist>=1.1.1 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (1.3.3)
+Requirement already satisfied: aiosignal>=1.1.2 in /home/zack/.local/lib/python3.10/site-packages (from aiohttp->gradio) (1.3.1)
+Requirement already satisfied: starlette<0.28.0,>=0.27.0 in /home/zack/.local/lib/python3.10/site-packages (from fastapi->gradio) (0.27.0)
+Requirement already satisfied: certifi in /home/zack/.local/lib/python3.10/site-packages (from httpx->gradio_client) (2023.5.7)
+Requirement already satisfied: httpcore<0.18.0,>=0.15.0 in /home/zack/.local/lib/python3.10/site-packages (from httpx->gradio_client) (0.17.0)
+Requirement already satisfied: idna in /home/zack/.local/lib/python3.10/site-packages (from httpx->gradio_client) (3.4)
+Requirement already satisfied: sniffio in /home/zack/.local/lib/python3.10/site-packages (from httpx->gradio_client) (1.3.0)
+Requirement already satisfied: cycler>=0.10 in /usr/lib/python3/dist-packages (from matplotlib->gradio) (0.11.0)
+Requirement already satisfied: kiwisolver>=1.0.1 in /usr/lib/python3/dist-packages (from matplotlib->gradio) (1.3.2)
+Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/lib/python3/dist-packages (from matplotlib->gradio) (2.4.7)
+Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/zack/.local/lib/python3.10/site-packages (from requests->gradio_client) (1.26.17)
+Requirement already satisfied: anyio<5.0,>=3.0 in /home/zack/.local/lib/python3.10/site-packages (from httpcore<0.18.0,>=0.15.0->httpx->gradio_client) (3.6.2)
+Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /home/zack/.local/lib/python3.10/site-packages (from jsonschema>=3.0->altair>=4.2.0->gradio) (2023.7.1)
+Requirement already satisfied: referencing>=0.28.4 in /home/zack/.local/lib/python3.10/site-packages (from jsonschema>=3.0->altair>=4.2.0->gradio) (0.30.2)
+Requirement already satisfied: rpds-py>=0.7.1 in /home/zack/.local/lib/python3.10/site-packages (from jsonschema>=3.0->altair>=4.2.0->gradio) (0.10.3)
+Requirement already satisfied: uc-micro-py in /home/zack/.local/lib/python3.10/site-packages (from linkify-it-py<3,>=1->markdown-it-py[linkify]>=2.0.0->gradio) (1.0.2)
+Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.8.1->pandas->gradio) (1.16.0)

CONTRIBUTING.md

@@ -0,0 +1,248 @@
+# Contributing to Swarms
+
+Hi there! Thank you for even being interested in contributing to Swarms.
+As an open source project in a rapidly developing field, we are extremely open
+to contributions, whether they be in the form of new features, improved infra, better documentation, or bug fixes.
+
+## 🗺️ Guidelines
+
+### 👩‍💻 Contributing Code
+
+To contribute to this project, please follow a ["fork and pull request"](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow.
+Please do not try to push directly to this repo unless you are maintainer.
+
+Please follow the checked-in pull request template when opening pull requests. Note related issues and tag relevant
+maintainers.
+
+Pull requests cannot land without passing the formatting, linting and testing checks first. See
+[Common Tasks](#-common-tasks) for how to run these checks locally.
+
+It's essential that we maintain great documentation and testing. If you:
+- Fix a bug
+  - Add a relevant unit or integration test when possible. These live in `tests/unit_tests` and `tests/integration_tests`.
+- Make an improvement
+  - Update any affected example notebooks and documentation. These lives in `docs`.
+  - Update unit and integration tests when relevant.
+- Add a feature
+  - Add a demo notebook in `docs/modules`.
+  - Add unit and integration tests.
+
+We're a small, building-oriented team. If there's something you'd like to add or change, opening a pull request is the
+best way to get our attention.
+
+### 🚩GitHub Issues
+
+Our [issues](https://github.com/kyegomez/Swarms/issues) page is kept up to date
+with bugs, improvements, and feature requests. 
+
+There is a taxonomy of labels to help with sorting and discovery of issues of interest. Please use these to help
+organize issues.
+
+If you start working on an issue, please assign it to yourself.
+
+If you are adding an issue, please try to keep it focused on a single, modular bug/improvement/feature.
+If two issues are related, or blocking, please link them rather than combining them.
+
+We will try to keep these issues as up to date as possible, though
+with the rapid rate of develop in this field some may get out of date.
+If you notice this happening, please let us know.
+
+### 🙋Getting Help
+
+Our goal is to have the simplest developer setup possible. Should you experience any difficulty getting setup, please
+contact a maintainer! Not only do we want to help get you unblocked, but we also want to make sure that the process is
+smooth for future contributors.
+
+In a similar vein, we do enforce certain linting, formatting, and documentation standards in the codebase.
+If you are finding these difficult (or even just annoying) to work with, feel free to contact a maintainer for help -
+we do not want these to get in the way of getting good code into the codebase.
+
+## 🚀 Quick Start
+
+> **Note:** You can run this repository locally (which is described below) or in a [development container](https://containers.dev/) (which is described in the [.devcontainer folder](https://github.com/hwchase17/Swarms/tree/master/.devcontainer)).
+
+This project uses [Poetry](https://python-poetry.org/) as a dependency manager. Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.
+
+❗Note: If you use `Conda` or `Pyenv` as your environment / package manager, avoid dependency conflicts by doing the following first:
+1. *Before installing Poetry*, create and activate a new Conda env (e.g. `conda create -n Swarms python=3.9`)
+2. Install Poetry (see above)
+3. Tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
+4. Continue with the following steps.
+
+To install requirements:
+
+```bash
+poetry install -E all
+```
+
+This will install all requirements for running the package, examples, linting, formatting, tests, and coverage. Note the `-E all` flag will install all optional dependencies necessary for integration testing.
+
+❗Note: If you're running Poetry 1.4.1 and receive a `WheelFileValidationError` for `debugpy` during installation, you can try either downgrading to Poetry 1.4.0 or disabling "modern installation" (`poetry config installer.modern-installation false`) and re-install requirements. See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
+
+Now, you should be able to run the common tasks in the following section. To double check, run `make test`, all tests should pass. If they don't you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
+
+## ✅ Common Tasks
+
+Type `make` for a list of common tasks.
+
+### Code Formatting
+
+Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [isort](https://pycqa.github.io/isort/).
+
+To run formatting for this project:
+
+```bash
+make format
+```
+
+### Linting
+
+Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [isort](https://pycqa.github.io/isort/), [flake8](https://flake8.pycqa.org/en/latest/), and [mypy](http://mypy-lang.org/).
+
+To run linting for this project:
+
+```bash
+make lint
+```
+
+We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
+
+### Coverage
+
+Code coverage (i.e. the amount of code that is covered by unit tests) helps identify areas of the code that are potentially more or less brittle.
+
+To get a report of current coverage, run the following:
+
+```bash
+make coverage
+```
+
+### Working with Optional Dependencies
+
+Swarms relies heavily on optional dependencies to keep the Swarms package lightweight.
+
+If you're adding a new dependency to Swarms, assume that it will be an optional dependency, and
+that most users won't have it installed.
+
+Users that do not have the dependency installed should be able to **import** your code without
+any side effects (no warnings, no errors, no exceptions). 
+
+To introduce the dependency to the pyproject.toml file correctly, please do the following: 
+
+1. Add the dependency to the main group as an optional dependency
+  ```bash
+  poetry add --optional [package_name]
+  ```
+2. Open pyproject.toml and add the dependency to the `extended_testing` extra
+3. Relock the poetry file to update the extra.
+  ```bash
+  poetry lock --no-update
+  ```
+4. Add a unit test that the very least attempts to import the new code. Ideally the unit
+test makes use of lightweight fixtures to test the logic of the code.
+5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
+
+### Testing
+
+See section about optional dependencies.
+
+#### Unit Tests
+
+Unit tests cover modular logic that does not require calls to outside APIs.
+
+To run unit tests:
+
+```bash
+make test
+```
+
+To run unit tests in Docker:
+
+```bash
+make docker_tests
+```
+
+If you add new logic, please add a unit test.
+
+
+
+#### Integration Tests
+
+Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
+
+**warning** Almost no tests should be integration tests. 
+
+  Tests that require making network connections make it difficult for other
+  developers to test the code.
+
+  Instead favor relying on `responses` library and/or mock.patch to mock
+  requests using small fixtures.
+
+To run integration tests:
+
+```bash
+make integration_tests
+```
+
+If you add support for a new external API, please add a new integration test.
+
+### Adding a Jupyter Notebook
+
+If you are adding a Jupyter notebook example, you'll want to install the optional `dev` dependencies.
+
+To install dev dependencies:
+
+```bash
+poetry install --with dev
+```
+
+Launch a notebook:
+
+```bash
+poetry run jupyter notebook
+```
+
+When you run `poetry install`, the `Swarms` package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.
+
+## Documentation
+
+### Contribute Documentation
+
+Docs are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
+
+For that reason, we ask that you add good documentation to all classes and methods.
+
+Similar to linting, we recognize documentation can be annoying. If you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
+
+### Build Documentation Locally
+
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make docs_clean
+```
+
+Next, you can run the linkchecker to make sure all links are valid:
+
+```bash
+make docs_linkcheck
+```
+
+Finally, you can build the documentation as outlined below:
+
+```bash
+make docs_build
+```
+
+## 🏭 Release Process
+
+As of now, Swarms has an ad hoc release process: releases are cut with high frequency by
+a developer and published to [PyPI](https://pypi.org/project/Swarms/).
+
+Swarms follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
+even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
+
+### 🌟 Recognition
+
+If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
+If you have a Twitter account you would like us to mention, please let us know in the PR or in another manner.

Dockerfile

@@ -0,0 +1,48 @@
+# This is a Dockerfile for running unit tests
+
+ARG POETRY_HOME=/opt/poetry
+
+# Use the Python base image
+FROM python:3.11.2-bullseye AS builder
+
+# Define the version of Poetry to install (default is 1.4.2)
+ARG POETRY_VERSION=1.4.2
+
+# Define the directory to install Poetry to (default is /opt/poetry)
+ARG POETRY_HOME
+
+# Create a Python virtual environment for Poetry and install it
+RUN python3 -m venv ${POETRY_HOME} && \
+    $POETRY_HOME/bin/pip install --upgrade pip && \
+    $POETRY_HOME/bin/pip install poetry==${POETRY_VERSION}
+
+# Test if Poetry is installed in the expected path
+RUN echo "Poetry version:" && $POETRY_HOME/bin/poetry --version
+
+# Set the working directory for the app
+WORKDIR /app
+
+# Use a multi-stage build to install dependencies
+FROM builder AS dependencies
+
+ARG POETRY_HOME
+
+# Copy only the dependency files for installation
+COPY pyproject.toml poetry.lock poetry.toml ./
+
+# Install the Poetry dependencies (this layer will be cached as long as the dependencies don't change)
+RUN $POETRY_HOME/bin/poetry install --no-interaction --no-ansi --with test
+
+# Use a multi-stage build to run tests
+FROM dependencies AS tests
+
+# Copy the rest of the app source code (this layer will be invalidated and rebuilt whenever the source code changes)
+COPY . .
+
+RUN /opt/poetry/bin/poetry install --no-interaction --no-ansi --with test
+
+# Set the entrypoint to run tests using Poetry
+ENTRYPOINT ["/opt/poetry/bin/poetry", "run", "pytest"]
+
+# Set the default command to run all unit tests
+CMD ["tests/"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,12 +1,310 @@
 ---
-title: Omni Bot
-emoji: 🌍
-colorFrom: pink
-colorTo: indigo
+title: omni_bot
+app_file: omni_ui.py
 sdk: gradio
-sdk_version: 3.47.1
-app_file: app.py
-pinned: false
+sdk_version: 3.33.1
 ---
+![Swarming banner icon](images/swarmsbanner.png)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+
+Swarms is a modular framework that enables reliable and useful multi-agent collaboration at scale to automate real-world tasks.
+
+
+[![GitHub issues](https://img.shields.io/github/issues/kyegomez/swarms)](https://github.com/kyegomez/swarms/issues) [![GitHub forks](https://img.shields.io/github/forks/kyegomez/swarms)](https://github.com/kyegomez/swarms/network) [![GitHub stars](https://img.shields.io/github/stars/kyegomez/swarms)](https://github.com/kyegomez/swarms/stargazers) [![GitHub license](https://img.shields.io/github/license/kyegomez/swarms)](https://github.com/kyegomez/swarms/blob/main/LICENSE)[![GitHub star chart](https://img.shields.io/github/stars/kyegomez/swarms?style=social)](https://star-history.com/#kyegomez/swarms)[![Dependency Status](https://img.shields.io/librariesio/github/kyegomez/swarms)](https://libraries.io/github/kyegomez/swarms) [![Downloads](https://static.pepy.tech/badge/swarms/month)](https://pepy.tech/project/swarms)
+
+
+### Share on Social Media
+
+[![Join the Agora discord](https://img.shields.io/discord/1110910277110743103?label=Discord&logo=discord&logoColor=white&style=plastic&color=d7b023)![Share on Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Share%20%40kyegomez/swarms)](https://twitter.com/intent/tweet?text=Check%20out%20this%20amazing%20AI%20project:%20&url=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms) [![Share on Facebook](https://img.shields.io/badge/Share-%20facebook-blue)](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms) [![Share on LinkedIn](https://img.shields.io/badge/Share-%20linkedin-blue)](https://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms&title=&summary=&source=)
+
+[![Share on Reddit](https://img.shields.io/badge/-Share%20on%20Reddit-orange)](https://www.reddit.com/submit?url=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms&title=Swarms%20-%20the%20future%20of%20AI) [![Share on Hacker News](https://img.shields.io/badge/-Share%20on%20Hacker%20News-orange)](https://news.ycombinator.com/submitlink?u=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms&t=Swarms%20-%20the%20future%20of%20AI) [![Share on Pinterest](https://img.shields.io/badge/-Share%20on%20Pinterest-red)](https://pinterest.com/pin/create/button/?url=https%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms&media=https%3A%2F%2Fexample.com%2Fimage.jpg&description=Swarms%20-%20the%20future%20of%20AI) [![Share on WhatsApp](https://img.shields.io/badge/-Share%20on%20WhatsApp-green)](https://api.whatsapp.com/send?text=Check%20out%20Swarms%20-%20the%20future%20of%20AI%20%23swarms%20%23AI%0A%0Ahttps%3A%2F%2Fgithub.com%2Fkyegomez%2Fswarms)
+
+</div>
+
+
+## Purpose
+At Swarms, we're transforming the landscape of AI from siloed AI agents to a unified 'swarm' of intelligence. Through relentless iteration and the power of collective insight from our 1500+ Agora researchers, we're developing a groundbreaking framework for AI collaboration. Our mission is to catalyze a paradigm shift, advancing Humanity with the power of unified autonomous AI agent swarms.
+
+-----
+
+# 🤝 Schedule a 1-on-1 Session
+Book a [1-on-1 Session with Kye](https://calendly.com/apacai/agora), the Creator, to discuss any issues, provide feedback, or explore how we can improve Swarms for you.
+
+
+## Hiring
+We're hiring: Engineers, Researchers, Interns And, salesprofessionals to work on democratizing swarms, email me at with your story at `kye@apac.ai`
+
+----------
+
+## Installation
+* `pip3 install swarms`
+
+---
+
+## Usage
+We have a small gallery of examples to run here, [for more check out the docs to build your own agent and or swarms!](https://docs.apac.ai)
+
+### `MultiAgentDebate`
+
+- `MultiAgentDebate` is a simple class that enables multi agent collaboration.
+
+```python
+from swarms.workers import Worker
+from swarms.swarms import MultiAgentDebate, select_speaker
+from langchain.llms import OpenAIChat
+
+llm = OpenAIChat(
+    model_name='gpt-4', 
+    openai_api_key="api-key", 
+    temperature=0.5
+)
+
+node = Worker(
+    llm=llm,
+    ai_name="Optimus Prime",
+    ai_role="Worker in a swarm",
+    external_tools = None,
+    human_in_the_loop = False,
+    temperature = 0.5,
+)
+
+node2 = Worker(
+    llm=llm,
+    ai_name="Bumble Bee",
+    ai_role="Worker in a swarm",
+    external_tools = None,
+    human_in_the_loop = False,
+    temperature = 0.5,
+)
+
+node3 = Worker(
+    llm=llm,
+    ai_name="Bumble Bee",
+    ai_role="Worker in a swarm",
+    external_tools = None,
+    human_in_the_loop = False,
+    temperature = 0.5,
+)
+
+agents = [
+    node,
+    node2,
+    node3
+]
+
+# Initialize multi-agent debate with the selection function
+debate = MultiAgentDebate(agents, select_speaker)
+
+# Run task
+task = "What were the winning boston marathon times for the past 5 years (ending in 2022)? Generate a table of the year, name, country of origin, and times."
+results = debate.run(task, max_iters=4)
+
+# Print results
+for result in results:
+    print(f"Agent {result['agent']} responded: {result['response']}")
+```
+
+----
+
+### `Worker`
+- The `Worker` is an fully feature complete agent with an llm, tools, and a vectorstore for long term memory!
+
+```python
+from langchain.llms import ChatOpenAI
+from swarms import Worker
+
+llm = ChatOpenAI(
+    model_name='gpt-4', 
+    openai_api_key="api-key", 
+    temperature=0.5
+)
+
+node = Worker(
+    llm=llm,
+    ai_name="Optimus Prime",
+    ai_role="Worker in a swarm",
+    external_tools = None,
+    human_in_the_loop = False,
+    temperature = 0.5,
+)
+
+task = "What were the winning boston marathon times for the past 5 years (ending in 2022)? Generate a table of the year, name, country of origin, and times."
+response = node.run(task)
+print(response)
+
+```
+
+------
+
+### `OmniModalAgent`
+- OmniModal Agent is an LLM that access to 10+ multi-modal encoders and diffusers! It can generate images, videos, speech, music and so much more, get started with:
+
+```python
+from langchain.llms import OpenAIChat
+from swarms.agents import OmniModalAgent
+
+
+llm = OpenAIChat(model_name="gpt-4")
+
+agent = OmniModalAgent(llm)
+
+agent.run("Create a video of a swarm of fish")
+
+```
+
+- OmniModal Agent has a ui in the root called `python3 omni_ui.py`
+
+---
+
+# Documentation
+For documentation, go here, [swarms.apac.ai](https://swarms.apac.ai)
+
+**NOTE: We need help building the documentation**
+
+-----
+
+# Docker Setup
+The docker file is located in the docker folder in the `infra` folder, [click here and navigate here in your environment](/infra/Docker)
+
+* Build the Docker image
+
+* You can build the Docker image using the provided Dockerfile. Navigate to the infra/Docker directory where the Dockerfiles are located.
+
+* For the CPU version, use:
+
+```bash
+docker build -t swarms-api:latest -f Dockerfile.cpu .
+```
+For the GPU version, use:
+
+```bash
+docker build -t swarms-api:gpu -f Dockerfile.gpu .
+```
+### Run the Docker container
+
+After building the Docker image, you can run the Swarms API in a Docker container. Replace your_redis_host and your_redis_port with your actual Redis host and port.
+
+For the CPU version:
+
+```bash
+docker run -p 8000:8000 -e REDIS_HOST=your_redis_host -e REDIS_PORT=your_redis_port swarms-api:latest
+```
+
+## For the GPU version:
+```bash
+docker run --gpus all -p 8000:8000 -e REDIS_HOST=your_redis_host -e REDIS_PORT=your_redis_port swarms-api:gpu
+```
+
+## Access the Swarms API
+
+* The Swarms API will be accessible at http://localhost:8000. You can use tools like curl or Postman to send requests to the API.
+
+Here's an example curl command to send a POST request to the /chat endpoint:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{"api_key": "your_openai_api_key", "objective": "your_objective"}' http://localhost:8000/chat
+```
+Replace your_openai_api_key and your_objective with your actual OpenAI API key and objective.
+
+----
+
+
+# ✨ Features
+* Easy to use Base LLMs, `OpenAI` `Palm` `Anthropic` `HuggingFace`
+* Enterprise Grade, Production Ready with robust Error Handling
+* Multi-Modality Native with Multi-Modal LLMs as tools
+* Infinite Memory Processing: Store infinite sequences of infinite Multi-Modal data, text, images, videos, audio
+* Usability: Extreme emphasis on useability, code is at it's theortical minimum simplicity factor to use
+* Reliability: Outputs that accomplish tasks and activities you wish to execute.
+* Fluidity: A seamless all-around experience to build production grade workflows
+* Speed: Lower the time to automate tasks by 90%. 
+* Simplicity: Swarms is extremely simple to use, if not thee simplest agent framework of all time
+* Powerful: Swarms is capable of building entire software apps, to large scale data analysis, and handling chaotic situations
+
+
+-----
+
+## Contribute
+We're always looking for contributors to help us improve and expand this project. If you're interested, please check out our [Contributing Guidelines](DOCS/C0NTRIBUTING.md).
+
+Thank you for being a part of our project!
+
+---
+# Roadmap
+
+Please checkout our [Roadmap](DOCS/ROADMAP.md) and consider contributing to make the dream of Swarms real to advance Humanity.
+
+## Optimization Priorities
+
+1. **Reliability**: Increase the reliability of the swarm - obtaining the desired output with a basic and un-detailed input.
+
+2. **Speed**: Reduce the time it takes for the swarm to accomplish tasks by improving the communication layer, critiquing, and self-alignment with meta prompting.
+
+3. **Scalability**: Ensure that the system is asynchronous, concurrent, and self-healing to support scalability.
+
+Our goal is to continuously improve Swarms by following this roadmap, while also being adaptable to new needs and opportunities as they arise.
+
+---
+
+# Bounty Program
+
+Our bounty program is an exciting opportunity for contributors to help us build the future of Swarms. By participating, you can earn rewards while contributing to a project that aims to revolutionize digital activity.
+
+Here's how it works:
+
+1. **Check out our Roadmap**: We've shared our roadmap detailing our short and long-term goals. These are the areas where we're seeking contributions.
+
+2. **Pick a Task**: Choose a task from the roadmap that aligns with your skills and interests. If you're unsure, you can reach out to our team for guidance.
+
+3. **Get to Work**: Once you've chosen a task, start working on it. Remember, quality is key. We're looking for contributions that truly make a difference.
+
+4. **Submit your Contribution**: Once your work is complete, submit it for review. We'll evaluate your contribution based on its quality, relevance, and the value it brings to Swarms.
+
+5. **Earn Rewards**: If your contribution is approved, you'll earn a bounty. The amount of the bounty depends on the complexity of the task, the quality of your work, and the value it brings to Swarms.
+
+---
+
+## The Plan
+
+### Phase 1: Building the Foundation
+In the first phase, our focus is on building the basic infrastructure of Swarms. This includes developing key components like the Swarms class, integrating essential tools, and establishing task completion and evaluation logic. We'll also start developing our testing and evaluation framework during this phase. If you're interested in foundational work and have a knack for building robust, scalable systems, this phase is for you.
+
+### Phase 2: Optimizing the System
+In the second phase, we'll focus on optimizng Swarms by integrating more advanced features, improving the system's efficiency, and refining our testing and evaluation framework. This phase involves more complex tasks, so if you enjoy tackling challenging problems and contributing to the development of innovative features, this is the phase for you.
+
+### Phase 3: Towards Super-Intelligence
+The third phase of our bounty program is the most exciting - this is where we aim to achieve super-intelligence. In this phase, we'll be working on improving the swarm's capabilities, expanding its skills, and fine-tuning the system based on real-world testing and feedback. If you're excited about the future of AI and want to contribute to a project that could potentially transform the digital world, this is the phase for you.
+
+Remember, our roadmap is a guide, and we encourage you to bring your own ideas and creativity to the table. We believe that every contribution, no matter how small, can make a difference. So join us on this exciting journey and help us create the future of Swarms.
+
+<!-- **To participate in our bounty program, visit the [Swarms Bounty Program Page](https://swarms.ai/bounty).** Let's build the future together! -->
+
+
+
+---
+
+# EcoSystem
+
+* [The-Compiler, compile natural language into serene, reliable, and secure programs](https://github.com/kyegomez/the-compiler)
+
+*[The Replicator, an autonomous swarm that conducts Multi-Modal AI research by creating new underlying mathematical operations and models](https://github.com/kyegomez/The-Replicator)
+
+* Make a swarm that checks arxviv for papers -> checks if there is a github link -> then implements them and checks them
+
+* [SwarmLogic, where a swarm is your API, database, and backend!](https://github.com/kyegomez/SwarmLogic)
+
+---
+
+# Demos
+
+![Swarms Demo](images/Screenshot_48.png)
+
+## Swarm Video Demo {Click for more}
+
+[![Watch the swarm video](https://img.youtube.com/vi/Br62cDMYXgc/maxresdefault.jpg)](https://youtu.be/Br62cDMYXgc)
+
+---
+
+# Contact 
+For enterprise and production ready deployments, allow us to discover more about you and your story, [book a call with us here](https://www.apac.ai/Setup-Call)

api/app.py

@@ -0,0 +1,47 @@
+import logging
+import os
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi_cache.decorator import cache
+from fastapi_cache.coder import JsonCoder
+
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.redis import RedisBackend
+from aioredis import Redis
+
+from pydantic import BaseModel
+from swarms.swarms.swarms import swarm
+from fastapi_limiter import FastAPILimiter
+
+from fastapi_limiter.depends import RateLimiter
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class SwarmInput(BaseModel):
+    api_key: str
+    objective: str
+
+app = FastAPI()
+
+@app.on_event("startup")
+async def startup():
+    redis_host = os.getenv("REDIS_HOST", "localhost")
+    redis_port = int(os.getenv("REDIS_PORT", 6379))
+    redis = await Redis.create(redis_host, redis_port)
+    FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache", coder=JsonCoder())
+    await FastAPILimiter.init(f"redis://{redis_host}:{redis_port}")
+
+@app.post("/chat", dependencies=[Depends(RateLimiter(times=2, minutes=1))])
+@cache(expire=60)  # Cache results for 1 minute
+async def run(swarm_input: SwarmInput):
+    try:
+        results = swarm(swarm_input.api_key, swarm_input.objective)
+        if not results:
+            raise HTTPException(status_code=500, detail="Failed to run swarms")
+        return {"results": results}
+    except ValueError as ve:
+        logging.error("A ValueError occurred", exc_info=True)
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception:
+        logging.error("An error occurred", exc_info=True)
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")

api/olds/container.py

@@ -0,0 +1,62 @@
+import os
+from pathlib import Path
+from typing import Dict, List
+
+from fastapi.templating import Jinja2Templates
+
+from swarms.agents.utils.agent_creator import AgentManager
+from swarms.utils.main import BaseHandler, FileHandler, FileType
+from swarms.tools.main import ExitConversation, RequestsGet, CodeEditor, Terminal
+
+from swarms.utils.main import CsvToDataframe
+
+from swarms.tools.main import BaseToolSet
+
+from swarms.utils.main import StaticUploader
+
+BASE_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.chdir(BASE_DIR / os.environ["PLAYGROUND_DIR"])
+
+#
+toolsets: List[BaseToolSet] = [
+    Terminal(),
+    CodeEditor(),
+    RequestsGet(),
+    ExitConversation(),
+]
+handlers: Dict[FileType, BaseHandler] = {FileType.DATAFRAME: CsvToDataframe()}
+
+if os.environ["USE_GPU"]:
+    import torch
+
+    # from core.handlers.image import ImageCaptioning
+    from swarms.tools.main import ImageCaptioning
+    from swarms.tools.main import (
+        ImageEditing,
+        InstructPix2Pix,
+        Text2Image,
+        VisualQuestionAnswering,
+    )
+
+    if torch.cuda.is_available():
+        toolsets.extend(
+            [
+                Text2Image("cuda"),
+                ImageEditing("cuda"),
+                InstructPix2Pix("cuda"),
+                VisualQuestionAnswering("cuda"),
+            ]
+        )
+        handlers[FileType.IMAGE] = ImageCaptioning("cuda")
+
+agent_manager = AgentManager.create(toolsets=toolsets)
+
+file_handler = FileHandler(handlers=handlers, path=BASE_DIR)
+
+templates = Jinja2Templates(directory=BASE_DIR / "api" / "templates")
+
+uploader = StaticUploader.from_settings(
+ path=BASE_DIR / "static", endpoint="static"
+)
+
+reload_dirs = [BASE_DIR / "core", BASE_DIR / "api"]

api/olds/main.py

@@ -0,0 +1,130 @@
+import os
+
+import re
+from multiprocessing import Process
+from tempfile import NamedTemporaryFile
+from typing import List, TypedDict
+
+import uvicorn
+from fastapi import FastAPI, Request, UploadFile
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from api.olds.container import agent_manager, file_handler, reload_dirs, templates, uploader
+from api.olds.worker import get_task_result, start_worker, task_execute
+# from env import settings
+
+app = FastAPI()
+
+app.mount("/static", StaticFiles(directory=uploader.path), name="static")
+
+
+class ExecuteRequest(BaseModel):
+    session: str
+    prompt: str
+    files: List[str]
+
+
+class ExecuteResponse(TypedDict):
+    answer: str
+    files: List[str]
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/dashboard", response_class=HTMLResponse)
+async def dashboard(request: Request):
+    return templates.TemplateResponse("dashboard.html", {"request": request})
+
+
+@app.post("/upload")
+async def create_upload_file(files: List[UploadFile]):
+    urls = []
+    for file in files:
+        extension = "." + file.filename.split(".")[-1]
+        with NamedTemporaryFile(suffix=extension) as tmp_file:
+            tmp_file.write(file.file.read())
+            tmp_file.flush()
+            urls.append(uploader.upload(tmp_file.name))
+    return {"urls": urls}
+
+
+@app.post("/api/execute")
+async def execute(request: ExecuteRequest) -> ExecuteResponse:
+    query = request.prompt
+    files = request.files
+    session = request.session
+
+    executor = agent_manager.create_executor(session)
+
+    promptedQuery = "\n".join([file_handler.handle(file) for file in files])
+    promptedQuery += query
+
+    try:
+        res = executor({"input": promptedQuery})
+    except Exception as e:
+        return {"answer": str(e), "files": []}
+
+    files = re.findall(r"\[file://\S*\]", res["output"])
+    files = [file[1:-1].split("file://")[1] for file in files]
+
+    return {
+        "answer": res["output"],
+        "files": [uploader.upload(file) for file in files],
+    }
+
+
+@app.post("/api/execute/async")
+async def execute_async(request: ExecuteRequest):
+    query = request.prompt
+    files = request.files
+    session = request.session
+
+    promptedQuery = "\n".join([file_handler.handle(file) for file in files])
+    promptedQuery += query
+
+    execution = task_execute.delay(session, promptedQuery)
+    return {"id": execution.id}
+
+
+@app.get("/api/execute/async/{execution_id}")
+async def execute_async(execution_id: str):
+    execution = get_task_result(execution_id)
+
+    result = {}
+    if execution.status == "SUCCESS" and execution.result:
+        output = execution.result.get("output", "")
+        files = re.findall(r"\[file://\S*\]", output)
+        files = [file[1:-1].split("file://")[1] for file in files]
+        result = {
+            "answer": output,
+            "files": [uploader.upload(file) for file in files],
+        }
+
+    return {
+        "status": execution.status,
+        "info": execution.info,
+        "result": result,
+    }
+
+
+def serve():
+    p = Process(target=start_worker, args=[])
+    p.start()
+    uvicorn.run("api.main:app", host="0.0.0.0", port=os.environ["EVAL_PORT"])
+
+
+def dev():
+    p = Process(target=start_worker, args=[])
+    p.start()
+    uvicorn.run(
+        "api.main:app",
+        host="0.0.0.0",
+        port=os.environ["EVAL_PORT"],
+        reload=True,
+        reload_dirs=reload_dirs,
+    )

api/olds/worker.py

@@ -0,0 +1,44 @@
+import os
+
+from celery import Celery
+from celery.result import AsyncResult
+
+from api.olds.container import agent_manager
+
+
+celery_app = Celery(__name__)
+celery_app.conf.broker_url = os.environ["CELERY_BROKER_URL"]
+celery_app.conf.result_backend = os.environ["CELERY_BROKER_URL"]
+celery_app.conf.update(
+    task_track_started=True,
+    task_serializer="json",
+    accept_content=["json"],  # Ignore other content
+    result_serializer="json",
+    enable_utc=True,
+)
+
+
+@celery_app.task(name="task_execute", bind=True)
+def task_execute(self, session: str, prompt: str):
+    executor = agent_manager.create_executor(session, self)
+    response = executor({"input": prompt})
+    result = {"output": response["output"]}
+
+    previous = AsyncResult(self.request.id)
+    if previous and previous.info:
+        result.update(previous.info)
+
+    return result
+
+
+def get_task_result(task_id):
+    return AsyncResult(task_id)
+
+
+def start_worker():
+    celery_app.worker_main(
+        [
+            "worker",
+            "--loglevel=INFO",
+        ]
+    )

apps/discord.py

@@ -0,0 +1,38 @@
+from discord.ext import commands
+from langchain.llms import OpenAIChat
+from swarms.agents import OmniModalAgent
+
+# Setup
+TOKEN = 'YOUR_DISCORD_BOT_TOKEN'
+bot = commands.Bot(command_prefix='!')
+
+# Initialize the OmniModalAgent
+llm = OpenAIChat(model_name="gpt-4")
+agent = OmniModalAgent(llm)
+
+@bot.event
+async def on_ready():
+    print(f'We have logged in as {bot.user}')
+
+@bot.command()
+async def greet(ctx):
+    """Greets the user."""
+    await ctx.send(f'Hello, {ctx.author.name}!')
+
+@bot.command()
+async def run(ctx, *, description: str):
+    """Generates a video based on the given description."""
+    response = agent.run(description)  # Assuming the response provides information or a link to the generated video
+    await ctx.send(response)
+
+@bot.command()
+async def help_me(ctx):
+    """Provides a list of commands and their descriptions."""
+    help_text = """
+    - `!greet`: Greets you.
+    - `!run [description]`: Generates a video based on the given description.
+    - `!help_me`: Provides this list of commands and their descriptions.
+    """
+    await ctx.send(help_text)
+
+bot.run(TOKEN)

docs/applications/customer_support.md

@@ -0,0 +1,42 @@
+## **Applications of Swarms: Revolutionizing Customer Support**
+
+---
+
+**Introduction**:  
+In today's fast-paced digital world, responsive and efficient customer support is a linchpin for business success. The introduction of AI-driven swarms in the customer support domain can transform the way businesses interact with and assist their customers. By leveraging the combined power of multiple AI agents working in concert, businesses can achieve unprecedented levels of efficiency, customer satisfaction, and operational cost savings.
+
+---
+
+### **The Benefits of Using Swarms for Customer Support:**
+
+1. **24/7 Availability**: Swarms never sleep. Customers receive instantaneous support at any hour, ensuring constant satisfaction and loyalty.
+  
+2. **Infinite Scalability**: Whether it's ten inquiries or ten thousand, swarms can handle fluctuating volumes with ease, eliminating the need for vast human teams and minimizing response times.
+  
+3. **Adaptive Intelligence**: Swarms learn collectively, meaning that a solution found for one customer can be instantly applied to benefit all. This leads to constantly improving support experiences, evolving with every interaction.
+
+---
+
+### **Features - Reinventing Customer Support**:
+
+- **AI Inbox Monitor**: Continuously scans email inboxes, identifying and categorizing support requests for swift responses.
+  
+- **Intelligent Debugging**: Proactively helps customers by diagnosing and troubleshooting underlying issues.
+  
+- **Automated Refunds & Coupons**: Seamless integration with payment systems like Stripe allows for instant issuance of refunds or coupons if a problem remains unresolved.
+  
+- **Full System Integration**: Holistically connects with CRM, email systems, and payment portals, ensuring a cohesive and unified support experience.
+  
+- **Conversational Excellence**: With advanced LLMs (Language Model Transformers), the swarm agents can engage in natural, human-like conversations, enhancing customer comfort and trust.
+  
+- **Rule-based Operation**: By working with rule engines, swarms ensure that all actions adhere to company guidelines, ensuring consistent, error-free support.
+  
+- **Turing Test Ready**: Crafted to meet and exceed the Turing Test standards, ensuring that every customer interaction feels genuine and personal.
+
+---
+
+**Conclusion**:  
+Swarms are not just another technological advancement; they represent the future of customer support. Their ability to provide round-the-clock, scalable, and continuously improving support can redefine customer experience standards. By adopting swarms, businesses can stay ahead of the curve, ensuring unparalleled customer loyalty and satisfaction.
+
+**Experience the future of customer support. Dive into the swarm revolution.**
+

docs/applications/marketing_agencies.md

@@ -0,0 +1,64 @@
+## **Swarms in Marketing Agencies: A New Era of Automated Media Strategy**
+
+---
+
+### **Introduction**: 
+- Brief background on marketing agencies and their role in driving brand narratives and sales.
+- Current challenges and pain points faced in media planning, placements, and budgeting.
+- Introduction to the transformative potential of swarms in reshaping the marketing industry.
+
+---
+
+### **1. Fundamental Problem: Media Plan Creation**:
+   - **Definition**: The challenge of creating an effective media plan that resonates with a target audience and aligns with brand objectives.
+   
+   - **Traditional Solutions and Their Shortcomings**: Manual brainstorming sessions, over-reliance on past strategies, and long turnaround times leading to inefficiency.
+   
+   - **How Swarms Address This Problem**: 
+      - **Benefit 1**: Automated Media Plan Generation – Swarms ingest branding summaries, objectives, and marketing strategies to generate media plans, eliminating guesswork and human error.
+      - **Real-world Application of Swarms**: The automation of media plans based on client briefs, including platform selections, audience targeting, and creative versions.
+
+---
+
+### **2. Fundamental Problem: Media Placements**:
+   - **Definition**: The tedious task of determining where ads will be placed, considering demographics, platform specifics, and more.
+   
+   - **Traditional Solutions and Their Shortcomings**: Manual placement leading to possible misalignment with target audiences and brand objectives.
+   
+   - **How Swarms Address This Problem**: 
+      - **Benefit 2**: Precision Media Placements – Swarms analyze audience data and demographics to suggest the best placements, optimizing for conversions and brand reach.
+      - **Real-world Application of Swarms**: Automated selection of ad placements across platforms like Facebook, Google, and DSPs based on media plans.
+
+---
+
+### **3. Fundamental Problem: Budgeting**:
+   - **Definition**: Efficiently allocating and managing advertising budgets across multiple campaigns, platforms, and timeframes.
+   
+   - **Traditional Solutions and Their Shortcomings**: Manual budgeting using tools like Excel, prone to errors, and inefficient shifts in allocations.
+   
+   - **How Swarms Address This Problem**: 
+      - **Benefit 3**: Intelligent Media Budgeting – Swarms enable dynamic budget allocation based on performance analytics, maximizing ROI.
+      - **Real-world Application of Swarms**: Real-time adjustments in budget allocations based on campaign performance, eliminating long waiting periods and manual recalculations.
+
+---
+
+### **Features**:
+1. Automated Media Plan Generator: Input your objectives and receive a comprehensive media plan.
+2. Precision Media Placement Tool: Ensure your ads appear in the right places to the right people.
+3. Dynamic Budget Allocation: Maximize ROI with real-time budget adjustments.
+4. Integration with Common Tools: Seamless integration with tools like Excel and APIs for exporting placements.
+5. Conversational Platform: A suite of tools built for modern marketing agencies, bringing all tasks under one umbrella.
+
+---
+
+### **Testimonials**:
+- "Swarms have completely revolutionized our media planning process. What used to take weeks now takes mere hours." - *Senior Media Strategist, Top-tier Marketing Agency*
+- "The precision with which we can place ads now is unprecedented. It's like having a crystal ball for marketing!" - *Campaign Manager, Global Advertising Firm*
+
+---
+
+### **Conclusion**: 
+- Reiterate the immense potential of swarms in revolutionizing media planning, placements, and budgeting for marketing agencies.
+- Call to action: For marketing agencies looking to step into the future and leave manual inefficiencies behind, swarms are the answer.
+
+---

docs/architecture.md

@@ -0,0 +1,358 @@
+# Architecture 
+
+## **1. Introduction**
+
+In today's rapidly evolving digital world, harnessing the collaborative power of multiple computational agents is more crucial than ever. 'Swarms' represents a bold stride in this direction—a scalable and dynamic framework designed to enable swarms of agents to function in harmony and tackle complex tasks. This document serves as a comprehensive guide, elucidating the underlying architecture and strategies pivotal to realizing the Swarms vision.
+
+---
+
+## **2. The Vision**
+
+At its heart, the Swarms framework seeks to emulate the collaborative efficiency witnessed in natural systems, like ant colonies or bird flocks. These entities, though individually simple, achieve remarkable outcomes through collaboration. Similarly, Swarms will unleash the collective potential of numerous agents, operating cohesively.
+
+---
+
+## **3. Architecture Overview**
+
+### **3.1 Agent Level**
+The base level that serves as the building block for all further complexity.
+
+#### Mechanics:
+* **Model**: At its core, each agent harnesses a powerful model like OpenAI's GPT.
+* **Vectorstore**: A memory structure allowing agents to store and retrieve information.
+* **Tools**: Utilities and functionalities that aid in the agent's task execution.
+
+#### Interaction:
+Agents interact with the external world through their model and tools. The Vectorstore aids in retaining knowledge and facilitating inter-agent communication.
+
+### **3.2 Worker Infrastructure Level**
+Building on the agent foundation, enhancing capability and readiness for swarm integration.
+
+#### Mechanics:
+* **Human Input Integration**: Enables agents to accept and understand human-provided instructions.
+* **Unique Identifiers**: Assigns each agent a unique ID to facilitate tracking and communication.
+* **Asynchronous Tools**: Bolsters agents' capability to multitask and interact in real-time.
+
+#### Interaction:
+Each worker is an enhanced agent, capable of operating independently or in sync with its peers, allowing for dynamic, scalable operations.
+
+### **3.3 Swarm Level**
+Multiple Worker Nodes orchestrated into a synchronized, collaborative entity.
+
+#### Mechanics:
+* **Orchestrator**: The maestro, responsible for directing the swarm, task allocation, and communication.
+* **Scalable Communication Layer**: Facilitates interactions among nodes and between nodes and the orchestrator.
+* **Task Assignment & Completion Protocols**: Structured procedures ensuring tasks are efficiently distributed and concluded.
+
+#### Interaction:
+Nodes collaborate under the orchestrator's guidance, ensuring tasks are partitioned appropriately, executed, and results consolidated.
+
+### **3.4 Hivemind Level**
+Envisioned as a 'Swarm of Swarms'. An upper echelon of collaboration.
+
+#### Mechanics:
+* **Hivemind Orchestrator**: Oversees multiple swarm orchestrators, ensuring harmony on a grand scale.
+* **Inter-Swarm Communication Protocols**: Dictates how swarms interact, exchange information, and co-execute tasks.
+
+#### Interaction:
+Multiple swarms, each a formidable force, combine their prowess under the Hivemind. This level tackles monumental tasks by dividing them among swarms.
+
+---
+
+## **4. Building the Framework: A Task Checklist**
+
+### **4.1 Foundations: Agent Level**
+* Define and standardize agent properties.
+* Integrate desired model (e.g., OpenAI's GPT) with agent.
+* Implement Vectorstore mechanisms: storage, retrieval, and communication protocols.
+* Incorporate essential tools and utilities.
+* Conduct preliminary testing: Ensure agents can execute basic tasks and utilize the Vectorstore.
+
+### **4.2 Enhancements: Worker Infrastructure Level**
+* Interface agents with human input mechanisms.
+* Assign and manage unique identifiers for each worker.
+* Integrate asynchronous capabilities: Ensure real-time response and multitasking.
+* Test worker nodes for both solitary and collaborative tasks.
+
+### **4.3 Cohesion: Swarm Level**
+* Design and develop the orchestrator: Ensure it can manage multiple worker nodes.
+* Establish a scalable and efficient communication layer.
+* Implement task distribution and retrieval protocols.
+* Test swarms for efficiency, scalability, and robustness.
+
+### **4.4 Apex Collaboration: Hivemind Level**
+* Build the Hivemind Orchestrator: Ensure it can oversee multiple swarms.
+* Define inter-swarm communication, prioritization, and task-sharing protocols.
+* Develop mechanisms to balance loads and optimize resource utilization across swarms.
+* Thoroughly test the Hivemind level for macro-task execution.
+
+---
+
+## **5. Integration and Communication Mechanisms**
+
+### **5.1 Vectorstore as the Universal Communication Layer**
+Serving as the memory and communication backbone, the Vectorstore must:
+* Facilitate rapid storage and retrieval of high-dimensional vectors.
+* Enable similarity-based lookups: Crucial for recognizing patterns or finding similar outputs.
+* Scale seamlessly as agent count grows.
+
+### **5.2 Orchestrator-Driven Communication**
+* Orchestrators, both at the swarm and hivemind level, should employ adaptive algorithms to optimally distribute tasks.
+* Ensure real-time monitoring of task execution and worker node health.
+* Integrate feedback loops: Allow for dynamic task reassignment in case of node failures or inefficiencies.
+
+---
+
+## **6. Conclusion & Forward Path**
+
+The Swarms framework, once realized, will usher in a new era of computational efficiency and collaboration. While the roadmap ahead is intricate, with diligent planning, development, and testing, Swarms will redefine the boundaries of collaborative computing.
+
+--------
+
+
+# Overview
+
+### 1. Model
+
+**Overview:**
+The foundational level where a trained model (e.g., OpenAI GPT model) is initialized. It's the base on which further abstraction levels build upon. It provides the core capabilities to perform tasks, answer queries, etc.
+
+**Diagram:**
+```
+[ Model (openai) ]
+```
+
+### 2. Agent Level
+
+**Overview:**
+At the agent level, the raw model is coupled with tools and a vector store, allowing it to be more than just a model. The agent can now remember, use tools, and become a more versatile entity ready for integration into larger systems.
+
+**Diagram:**
+```
++-----------+
+|   Agent   |
+| +-------+ |
+| | Model | |
+| +-------+ |
+| +-----------+ |
+| | VectorStore | |
+| +-----------+ |
+| +-------+ |
+| | Tools | |
+| +-------+ |
++-----------+
+```
+
+### 3. Worker Infrastructure Level
+
+**Overview:**
+The worker infrastructure is a step above individual agents. Here, an agent is paired with additional utilities like human input and other tools, making it a more advanced, responsive unit capable of complex tasks.
+
+**Diagram:**
+```
++----------------+
+|  WorkerNode    |
+| +-----------+  |
+| |   Agent   |  |
+| | +-------+ |  |
+| | | Model | |  |
+| | +-------+ |  |
+| | +-------+ |  |
+| | | Tools | |  |
+| | +-------+ |  |
+| +-----------+  |
+|                |
+| +-----------+  |
+| |Human Input|  |
+| +-----------+  |
+|                |
+| +-------+      |
+| | Tools |      |
+| +-------+      |
++----------------+
+```
+
+### 4. Swarm Level
+
+**Overview:**
+At the swarm level, the orchestrator is central. It's responsible for assigning tasks to worker nodes, monitoring their completion, and handling the communication layer (for example, through a vector store or another universal communication mechanism) between worker nodes.
+
+**Diagram:**
+```
+                     +------------+
+                     |Orchestrator|
+                     +------------+
+                           |
+            +---------------------------+
+            |                           |
+            |   Swarm-level Communication|
+            |          Layer (e.g.      |
+            |        Vector Store)      |
+            +---------------------------+
+             /          |          \         
+  +---------------+  +---------------+  +---------------+
+  |WorkerNode 1   |  |WorkerNode 2   |  |WorkerNode n   |
+  |               |  |               |  |               |
+  +---------------+  +---------------+  +---------------+
+   | Task Assigned   | Task Completed   | Communication |
+```
+
+### 5. Hivemind Level
+
+**Overview:**
+At the Hivemind level, it's a multi-swarm setup, with an upper-layer orchestrator managing multiple swarm-level orchestrators. The Hivemind orchestrator is responsible for broader tasks like assigning macro-tasks to swarms, handling inter-swarm communications, and ensuring the overall system is functioning smoothly.
+
+**Diagram:**
+```
+                     +--------+
+                     |Hivemind|
+                     +--------+
+                         |
+                 +--------------+
+                 |Hivemind      |
+                 |Orchestrator  |
+                 +--------------+
+            /         |          \         
+    +------------+  +------------+  +------------+
+    |Orchestrator|  |Orchestrator|  |Orchestrator|
+    +------------+  +------------+  +------------+
+        |               |               |
++--------------+ +--------------+ +--------------+
+|   Swarm-level| |   Swarm-level| |   Swarm-level|
+|Communication| |Communication| |Communication|
+|    Layer    | |    Layer    | |    Layer    |
++--------------+ +--------------+ +--------------+
+    /    \         /    \         /     \
++-------+ +-------+ +-------+ +-------+ +-------+
+|Worker | |Worker | |Worker | |Worker | |Worker |
+| Node  | | Node  | | Node  | | Node  | | Node  |
++-------+ +-------+ +-------+ +-------+ +-------+
+```
+
+This setup allows the Hivemind level to operate at a grander scale, with the capability to manage hundreds or even thousands of worker nodes across multiple swarms efficiently.
+
+
+
+-------
+# **Swarms Framework Development Strategy Checklist**
+
+## **Introduction**
+
+The development of the Swarms framework requires a systematic and granular approach to ensure that each component is robust and that the overall framework is efficient and scalable. This checklist will serve as a guide to building Swarms from the ground up, breaking down tasks into small, manageable pieces.
+
+---
+
+## **1. Agent Level Development**
+
+### **1.1 Model Integration**
+- [ ] Research the most suitable models (e.g., OpenAI's GPT).
+- [ ] Design an API for the agent to call the model.
+- [ ] Implement error handling when model calls fail.
+- [ ] Test the model with sample data for accuracy and speed.
+
+### **1.2 Vectorstore Implementation**
+- [ ] Design the schema for the vector storage system.
+- [ ] Implement storage methods to add, delete, and update vectors.
+- [ ] Develop retrieval methods with optimization for speed.
+- [ ] Create protocols for vector-based communication between agents.
+- [ ] Conduct stress tests to ascertain storage and retrieval speed.
+
+### **1.3 Tools & Utilities Integration**
+- [ ] List out essential tools required for agent functionality.
+- [ ] Develop or integrate APIs for each tool.
+- [ ] Implement error handling and logging for tool interactions.
+- [ ] Validate tools integration with unit tests.
+
+---
+
+## **2. Worker Infrastructure Level Development**
+
+### **2.1 Human Input Integration**
+- [ ] Design a UI/UX for human interaction with worker nodes.
+- [ ] Create APIs for input collection.
+- [ ] Implement input validation and error handling.
+- [ ] Test human input methods for clarity and ease of use.
+
+### **2.2 Unique Identifier System**
+- [ ] Research optimal formats for unique ID generation.
+- [ ] Develop methods for generating and assigning IDs to agents.
+- [ ] Implement a tracking system to manage and monitor agents via IDs.
+- [ ] Validate the uniqueness and reliability of the ID system.
+
+### **2.3 Asynchronous Operation Tools**
+- [ ] Incorporate libraries/frameworks to enable asynchrony.
+- [ ] Ensure tasks within an agent can run in parallel without conflict.
+- [ ] Test asynchronous operations for efficiency improvements.
+
+---
+
+## **3. Swarm Level Development**
+
+### **3.1 Orchestrator Design & Development**
+- [ ] Draft a blueprint of orchestrator functionalities.
+- [ ] Implement methods for task distribution among worker nodes.
+- [ ] Develop communication protocols for the orchestrator to monitor workers.
+- [ ] Create feedback systems to detect and address worker node failures.
+- [ ] Test orchestrator with a mock swarm to ensure efficient task allocation.
+
+### **3.2 Communication Layer Development**
+- [ ] Select a suitable communication protocol/framework (e.g., gRPC, WebSockets).
+- [ ] Design the architecture for scalable, low-latency communication.
+- [ ] Implement methods for sending, receiving, and broadcasting messages.
+- [ ] Test communication layer for reliability, speed, and error handling.
+
+### **3.3 Task Management Protocols**
+- [ ] Develop a system to queue, prioritize, and allocate tasks.
+- [ ] Implement methods for real-time task status tracking.
+- [ ] Create a feedback loop for completed tasks.
+- [ ] Test task distribution, execution, and feedback systems for efficiency.
+
+---
+
+## **4. Hivemind Level Development**
+
+### **4.1 Hivemind Orchestrator Development**
+- [ ] Extend swarm orchestrator functionalities to manage multiple swarms.
+- [ ] Create inter-swarm communication protocols.
+- [ ] Implement load balancing mechanisms to distribute tasks across swarms.
+- [ ] Validate hivemind orchestrator functionalities with multi-swarm setups.
+
+### **4.2 Inter-Swarm Communication Protocols**
+- [ ] Design methods for swarms to exchange data.
+- [ ] Implement data reconciliation methods for swarms working on shared tasks.
+- [ ] Test inter-swarm communication for efficiency and data integrity.
+
+---
+
+## **5. Scalability & Performance Testing**
+
+- [ ] Simulate heavy loads to test the limits of the framework.
+- [ ] Identify and address bottlenecks in both communication and computation.
+- [ ] Conduct speed tests under different conditions.
+- [ ] Test the system's responsiveness under various levels of stress.
+
+---
+
+## **6. Documentation & User Guide**
+
+- [ ] Develop detailed documentation covering architecture, setup, and usage.
+- [ ] Create user guides with step-by-step instructions.
+- [ ] Incorporate visual aids, diagrams, and flowcharts for clarity.
+- [ ] Update documentation regularly with new features and improvements.
+
+---
+
+## **7. Continuous Integration & Deployment**
+
+- [ ] Setup CI/CD pipelines for automated testing and deployment.
+- [ ] Ensure automatic rollback in case of deployment failures.
+- [ ] Integrate code quality and security checks in the pipeline.
+- [ ] Document deployment strategies and best practices.
+
+---
+
+## **Conclusion**
+
+The Swarms framework represents a monumental leap in agent-based computation. This checklist provides a thorough roadmap for the framework's development, ensuring that every facet is addressed in depth. Through diligent adherence to this guide, the Swarms vision can be realized as a powerful, scalable, and robust system ready to tackle the challenges of tomorrow.
+
+(Note: This document, given the word limit, provides a high-level overview. A full 5000-word document would delve into even more intricate details, nuances, potential pitfalls, and include considerations for security, user experience, compatibility, etc.)

docs/assets/css/extra.css

@@ -0,0 +1,7 @@
+.md-typeset__table {
+   min-width: 100%;
+}
+
+.md-typeset table:not([class]) {
+    display: table;
+}

docs/bounties.md

@@ -0,0 +1,86 @@
+# Bounty Program
+
+Our bounty program is an exciting opportunity for contributors to help us build the future of Swarms. By participating, you can earn rewards while contributing to a project that aims to revolutionize digital activity.
+
+Here's how it works:
+
+1. **Check out our Roadmap**: We've shared our roadmap detailing our short and long-term goals. These are the areas where we're seeking contributions.
+
+2. **Pick a Task**: Choose a task from the roadmap that aligns with your skills and interests. If you're unsure, you can reach out to our team for guidance.
+
+3. **Get to Work**: Once you've chosen a task, start working on it. Remember, quality is key. We're looking for contributions that truly make a difference.
+
+4. **Submit your Contribution**: Once your work is complete, submit it for review. We'll evaluate your contribution based on its quality, relevance, and the value it brings to Swarms.
+
+5. **Earn Rewards**: If your contribution is approved, you'll earn a bounty. The amount of the bounty depends on the complexity of the task, the quality of your work, and the value it brings to Swarms.
+
+## The Three Phases of Our Bounty Program
+
+### Phase 1: Building the Foundation
+In the first phase, our focus is on building the basic infrastructure of Swarms. This includes developing key components like the Swarms class, integrating essential tools, and establishing task completion and evaluation logic. We'll also start developing our testing and evaluation framework during this phase. If you're interested in foundational work and have a knack for building robust, scalable systems, this phase is for you.
+
+### Phase 2: Enhancing the System
+In the second phase, we'll focus on enhancing Swarms by integrating more advanced features, improving the system's efficiency, and refining our testing and evaluation framework. This phase involves more complex tasks, so if you enjoy tackling challenging problems and contributing to the development of innovative features, this is the phase for you.
+
+### Phase 3: Towards Super-Intelligence
+The third phase of our bounty program is the most exciting - this is where we aim to achieve super-intelligence. In this phase, we'll be working on improving the swarm's capabilities, expanding its skills, and fine-tuning the system based on real-world testing and feedback. If you're excited about the future of AI and want to contribute to a project that could potentially transform the digital world, this is the phase for you.
+
+Remember, our roadmap is a guide, and we encourage you to bring your own ideas and creativity to the table. We believe that every contribution, no matter how small, can make a difference. So join us on this exciting journey and help us create the future of Swarms.
+
+**To participate in our bounty program, visit the [Swarms Bounty Program Page](https://swarms.ai/bounty).** Let's build the future together!
+
+
+
+
+
+## Bounties for Roadmap Items
+
+To accelerate the development of Swarms and to encourage more contributors to join our journey towards automating every digital activity in existence, we are announcing a Bounty Program for specific roadmap items. Each bounty will be rewarded based on the complexity and importance of the task. Below are the items available for bounty:
+
+1. **Multi-Agent Debate Integration**: $2000
+2. **Meta Prompting Integration**: $1500
+3. **Swarms Class**: $1500
+4. **Integration of Additional Tools**: $1000
+5. **Task Completion and Evaluation Logic**: $2000
+6. **Ocean Integration**: $2500
+7. **Improved Communication**: $2000
+8. **Testing and Evaluation**: $1500
+9. **Worker Swarm Class**: $2000
+10. **Documentation**: $500
+
+For each bounty task, there will be a strict evaluation process to ensure the quality of the contribution. This process includes a thorough review of the code and extensive testing to ensure it meets our standards.
+
+# 3-Phase Testing Framework
+
+To ensure the quality and efficiency of the Swarm, we will introduce a 3-phase testing framework which will also serve as our evaluation criteria for each of the bounty tasks.
+
+## Phase 1: Unit Testing
+In this phase, individual modules will be tested to ensure that they work correctly in isolation. Unit tests will be designed for all functions and methods, with an emphasis on edge cases.
+
+## Phase 2: Integration Testing
+After passing unit tests, we will test the integration of different modules to ensure they work correctly together. This phase will also test the interoperability of the Swarm with external systems and libraries.
+
+## Phase 3: Benchmarking & Stress Testing
+In the final phase, we will perform benchmarking and stress tests. We'll push the limits of the Swarm under extreme conditions to ensure it performs well in real-world scenarios. This phase will measure the performance, speed, and scalability of the Swarm under high load conditions.
+
+By following this 3-phase testing framework, we aim to develop a reliable, high-performing, and scalable Swarm that can automate all digital activities. 
+
+# Reverse Engineering to Reach Phase 3
+
+To reach the Phase 3 level, we need to reverse engineer the tasks we need to complete. Here's an example of what this might look like:
+
+1. **Set Clear Expectations**: Define what success looks like for each task. Be clear about the outputs and outcomes we expect. This will guide our testing and development efforts.
+
+2. **Develop Testing Scenarios**: Create a comprehensive list of testing scenarios that cover both common and edge cases. This will help us ensure that our Swarm can handle a wide range of situations.
+
+3. **Write Test Cases**: For each scenario, write detailed test cases that outline the exact steps to be followed, the inputs to be used, and the expected outputs.
+
+4. **Execute the Tests**: Run the test cases on our Swarm, making note of any issues or bugs that arise.
+
+5. **Iterate and Improve**: Based on the results of our tests, iterate and improve our Swarm. This may involve fixing bugs, optimizing code, or redesigning parts of our system.
+
+6. **Repeat**: Repeat this process until our Swarm meets our expectations and passes all test cases.
+
+By following these steps, we will systematically build, test, and improve our Swarm until it reaches the Phase 3 level. This methodical approach will help us ensure that we create a reliable, high-performing, and scalable Swarm that can truly automate all digital activities.
+
+Let's shape the future of digital automation together!

docs/checklist.md

@@ -0,0 +1,122 @@
+# **Swarms Framework Development Strategy Checklist**
+
+## **Introduction**
+
+The development of the Swarms framework requires a systematic and granular approach to ensure that each component is robust and that the overall framework is efficient and scalable. This checklist will serve as a guide to building Swarms from the ground up, breaking down tasks into small, manageable pieces.
+
+---
+
+## **1. Agent Level Development**
+
+### **1.1 Model Integration**
+- [ ] Research the most suitable models (e.g., OpenAI's GPT).
+- [ ] Design an API for the agent to call the model.
+- [ ] Implement error handling when model calls fail.
+- [ ] Test the model with sample data for accuracy and speed.
+
+### **1.2 Vectorstore Implementation**
+- [ ] Design the schema for the vector storage system.
+- [ ] Implement storage methods to add, delete, and update vectors.
+- [ ] Develop retrieval methods with optimization for speed.
+- [ ] Create protocols for vector-based communication between agents.
+- [ ] Conduct stress tests to ascertain storage and retrieval speed.
+
+### **1.3 Tools & Utilities Integration**
+- [ ] List out essential tools required for agent functionality.
+- [ ] Develop or integrate APIs for each tool.
+- [ ] Implement error handling and logging for tool interactions.
+- [ ] Validate tools integration with unit tests.
+
+---
+
+## **2. Worker Infrastructure Level Development**
+
+### **2.1 Human Input Integration**
+- [ ] Design a UI/UX for human interaction with worker nodes.
+- [ ] Create APIs for input collection.
+- [ ] Implement input validation and error handling.
+- [ ] Test human input methods for clarity and ease of use.
+
+### **2.2 Unique Identifier System**
+- [ ] Research optimal formats for unique ID generation.
+- [ ] Develop methods for generating and assigning IDs to agents.
+- [ ] Implement a tracking system to manage and monitor agents via IDs.
+- [ ] Validate the uniqueness and reliability of the ID system.
+
+### **2.3 Asynchronous Operation Tools**
+- [ ] Incorporate libraries/frameworks to enable asynchrony.
+- [ ] Ensure tasks within an agent can run in parallel without conflict.
+- [ ] Test asynchronous operations for efficiency improvements.
+
+---
+
+## **3. Swarm Level Development**
+
+### **3.1 Orchestrator Design & Development**
+- [ ] Draft a blueprint of orchestrator functionalities.
+- [ ] Implement methods for task distribution among worker nodes.
+- [ ] Develop communication protocols for the orchestrator to monitor workers.
+- [ ] Create feedback systems to detect and address worker node failures.
+- [ ] Test orchestrator with a mock swarm to ensure efficient task allocation.
+
+### **3.2 Communication Layer Development**
+- [ ] Select a suitable communication protocol/framework (e.g., gRPC, WebSockets).
+- [ ] Design the architecture for scalable, low-latency communication.
+- [ ] Implement methods for sending, receiving, and broadcasting messages.
+- [ ] Test communication layer for reliability, speed, and error handling.
+
+### **3.3 Task Management Protocols**
+- [ ] Develop a system to queue, prioritize, and allocate tasks.
+- [ ] Implement methods for real-time task status tracking.
+- [ ] Create a feedback loop for completed tasks.
+- [ ] Test task distribution, execution, and feedback systems for efficiency.
+
+---
+
+## **4. Hivemind Level Development**
+
+### **4.1 Hivemind Orchestrator Development**
+- [ ] Extend swarm orchestrator functionalities to manage multiple swarms.
+- [ ] Create inter-swarm communication protocols.
+- [ ] Implement load balancing mechanisms to distribute tasks across swarms.
+- [ ] Validate hivemind orchestrator functionalities with multi-swarm setups.
+
+### **4.2 Inter-Swarm Communication Protocols**
+- [ ] Design methods for swarms to exchange data.
+- [ ] Implement data reconciliation methods for swarms working on shared tasks.
+- [ ] Test inter-swarm communication for efficiency and data integrity.
+
+---
+
+## **5. Scalability & Performance Testing**
+
+- [ ] Simulate heavy loads to test the limits of the framework.
+- [ ] Identify and address bottlenecks in both communication and computation.
+- [ ] Conduct speed tests under different conditions.
+- [ ] Test the system's responsiveness under various levels of stress.
+
+---
+
+## **6. Documentation & User Guide**
+
+- [ ] Develop detailed documentation covering architecture, setup, and usage.
+- [ ] Create user guides with step-by-step instructions.
+- [ ] Incorporate visual aids, diagrams, and flowcharts for clarity.
+- [ ] Update documentation regularly with new features and improvements.
+
+---
+
+## **7. Continuous Integration & Deployment**
+
+- [ ] Setup CI/CD pipelines for automated testing and deployment.
+- [ ] Ensure automatic rollback in case of deployment failures.
+- [ ] Integrate code quality and security checks in the pipeline.
+- [ ] Document deployment strategies and best practices.
+
+---
+
+## **Conclusion**
+
+The Swarms framework represents a monumental leap in agent-based computation. This checklist provides a thorough roadmap for the framework's development, ensuring that every facet is addressed in depth. Through diligent adherence to this guide, the Swarms vision can be realized as a powerful, scalable, and robust system ready to tackle the challenges of tomorrow.
+
+(Note: This document, given the word limit, provides a high-level overview. A full 5000-word document would delve into even more intricate details, nuances, potential pitfalls, and include considerations for security, user experience, compatibility, etc.)

docs/contributing.md

@@ -0,0 +1,123 @@
+# Contributing
+
+Thank you for your interest in contributing to Swarms! We welcome contributions from the community to help improve usability and readability. By contributing, you can be a part of creating a dynamic and interactive AI system.
+
+To get started, please follow the guidelines below.
+
+
+## Optimization Priorities
+
+To continuously improve Swarms, we prioritize the following design objectives:
+
+1. **Usability**: Increase the ease of use and user-friendliness of the swarm system to facilitate adoption and interaction with basic input.
+
+2. **Reliability**: Improve the swarm's ability to obtain the desired output even with basic and un-detailed input.
+
+3. **Speed**: Reduce the time it takes for the swarm to accomplish tasks by improving the communication layer, critiquing, and self-alignment with meta prompting.
+
+4. **Scalability**: Ensure that the system is asynchronous, concurrent, and self-healing to support scalability.
+
+Our goal is to continuously improve Swarms by following this roadmap while also being adaptable to new needs and opportunities as they arise.
+
+## Join the Swarms Community
+
+Join the Swarms community on Discord to connect with other contributors, coordinate work, and receive support.
+
+- [Join the Swarms Discord Server](https://discord.gg/qUtxnK2NMf)
+
+
+## Report and Issue
+The easiest way to contribute to our docs is through our public [issue tracker](https://github.com/kyegomez/swarms-docs/issues). Feel free to submit bugs, request features or changes, or contribute to the project directly. 
+
+## Pull Requests
+
+Swarms docs are built using [MkDocs](https://squidfunk.github.io/mkdocs-material/getting-started/). 
+
+To directly contribute to Swarms documentation, first fork the [swarms-docs](https://github.com/kyegomez/swarms-docs) repository to your GitHub account. Then clone your repository to your local machine.
+
+From inside the directory run: 
+
+```pip install -r requirements.txt```
+
+To run `swarms-docs` locally run: 
+
+```mkdocs serve```
+
+You should see something similar to the following: 
+
+```
+INFO     -  Building documentation...
+INFO     -  Cleaning site directory
+INFO     -  Documentation built in 0.19 seconds
+INFO     -  [09:28:33] Watching paths for changes: 'docs', 'mkdocs.yml'
+INFO     -  [09:28:33] Serving on http://127.0.0.1:8000/
+INFO     -  [09:28:37] Browser connected: http://127.0.0.1:8000/
+```
+
+Follow the typical PR process to contribute changes. 
+
+* Create a feature branch.
+* Commit changes.
+* Submit a PR.
+
+
+-------
+---
+
+## Taking on Tasks
+
+We have a growing list of tasks and issues that you can contribute to. To get started, follow these steps:
+
+1. Visit the [Swarms GitHub repository](https://github.com/kyegomez/swarms) and browse through the existing issues.
+
+2. Find an issue that interests you and make a comment stating that you would like to work on it. Include a brief description of how you plan to solve the problem and any questions you may have.
+
+3. Once a project coordinator assigns the issue to you, you can start working on it.
+
+If you come across an issue that is unclear but still interests you, please post in the Discord server mentioned above. Someone from the community will be able to help clarify the issue in more detail.
+
+We also welcome contributions to documentation, such as updating markdown files, adding docstrings, creating system architecture diagrams, and other related tasks.
+
+## Submitting Your Work
+
+To contribute your changes to Swarms, please follow these steps:
+
+1. Fork the Swarms repository to your GitHub account. You can do this by clicking on the "Fork" button on the repository page.
+
+2. Clone the forked repository to your local machine using the `git clone` command.
+
+3. Before making any changes, make sure to sync your forked repository with the original repository to keep it up to date. You can do this by following the instructions [here](https://docs.github.com/en/github/collaborating-with-pull-requests/syncing-a-fork).
+
+4. Create a new branch for your changes. This branch should have a descriptive name that reflects the task or issue you are working on.
+
+5. Make your changes in the branch, focusing on a small, focused change that only affects a few files.
+
+6. Run any necessary formatting or linting tools to ensure that your changes adhere to the project's coding standards.
+
+7. Once your changes are ready, commit them to your branch with descriptive commit messages.
+
+8. Push the branch to your forked repository.
+
+9. Create a pull request (PR) from your branch to the main Swarms repository. Provide a clear and concise description of your changes in the PR.
+
+10. Request a review from the project maintainers. They will review your changes, provide feedback, and suggest any necessary improvements.
+
+11. Make any required updates or address any feedback provided during the review process.
+
+12. Once your changes have been reviewed and approved, they will be merged into the main branch of the Swarms repository.
+
+13. Congratulations! You have successfully contributed to Swarms.
+
+Please note that during the review process, you may be asked to make changes or address certain issues. It is important to engage in open and constructive communication with the project maintainers to ensure the quality of your contributions.
+
+## Developer Setup
+
+If you are interested in setting up the Swarms development environment, please follow the instructions provided in the [developer setup guide](docs/developer-setup.md). This guide provides an overview of the different tools and technologies used in the project.
+
+## Join the Agora Community
+
+Swarms is brought to you by Agora, the open-source AI research organization. Join the Agora community to connect with other researchers and developers working on AI projects.
+
+- [Join the Agora Discord Server](https://discord.gg/qUtxnK2NMf)
+
+Thank you for your contributions and for being a part of the Swarms and Agora community! Together, we can advance Humanity through the power of AI.

docs/demos.md

@@ -0,0 +1,9 @@
+# Demo Ideas
+
+* We could also try to create an AI influencer run by a swarm, let it create a whole identity and generate images, memes, and other content for Twitter, Reddit, etc.
+
+* had a thought that we should have either a more general one of these or a swarm or both -- need something connecting all the calendars, events, and initiatives of all the AI communities, langchain, laion, eluther, lesswrong, gato, rob miles, chatgpt hackers, etc etc
+
+* Swarm of AI influencers to spread marketing
+
+* Delegation System to better organize teams: Start with a team of passionate humans and let them self-report their skills/strengths so the agent has a concept of who to delegate to, then feed the agent a huge task list (like the bullet list a few messages above) that it breaks down into actionable steps and "prompts" specific team members to complete tasks. Could even suggest breakout teams of a few people with complementary skills to tackle more complex tasks. There can also be a live board that updates each time a team member completes something, to encourage momentum and keep track of progress

docs/design.md

@@ -0,0 +1,152 @@
+# Design Philosophy Document for Swarms
+
+## Usable
+
+### Objective
+
+Our goal is to ensure that Swarms is intuitive and easy to use for all users, regardless of their level of technical expertise. This includes the developers who implement Swarms in their applications, as well as end users who interact with the implemented systems.
+
+### Tactics
+
+- Clear and Comprehensive Documentation: We will provide well-written and easily accessible documentation that guides users through using and understanding Swarms.
+- User-Friendly APIs: We'll design clean and self-explanatory APIs that help developers to understand their purpose quickly.
+- Prompt and Effective Support: We will ensure that support is readily available to assist users when they encounter problems or need help with Swarms.
+
+## Reliable
+
+### Objective
+
+Swarms should be dependable and trustworthy. Users should be able to count on Swarms to perform consistently and without error or failure.
+
+### Tactics
+
+- Robust Error Handling: We will focus on error prevention, detection, and recovery to minimize failures in Swarms.
+- Comprehensive Testing: We will apply various testing methodologies such as unit testing, integration testing, and stress testing to validate the reliability of our software.
+- Continuous Integration/Continuous Delivery (CI/CD): We will use CI/CD pipelines to ensure that all changes are tested and validated before they're merged into the main branch.
+
+## Fast
+
+### Objective
+
+Swarms should offer high performance and rapid response times. The system should be able to handle requests and tasks swiftly.
+
+### Tactics
+
+- Efficient Algorithms: We will focus on optimizing our algorithms and data structures to ensure they run as quickly as possible.
+- Caching: Where appropriate, we will use caching techniques to speed up response times.
+- Profiling and Performance Monitoring: We will regularly analyze the performance of Swarms to identify bottlenecks and opportunities for improvement.
+
+## Scalable
+
+### Objective
+
+Swarms should be able to grow in capacity and complexity without compromising performance or reliability. It should be able to handle increased workloads gracefully.
+
+### Tactics
+
+- Modular Architecture: We will design Swarms using a modular architecture that allows for easy scaling and modification.
+- Load Balancing: We will distribute tasks evenly across available resources to prevent overload and maximize throughput.
+- Horizontal and Vertical Scaling: We will design Swarms to be capable of both horizontal (adding more machines) and vertical (adding more power to an existing machine) scaling.
+
+### Philosophy
+
+Swarms is designed with a philosophy of simplicity and reliability. We believe that software should be a tool that empowers users, not a hurdle that they need to overcome. Therefore, our focus is on usability, reliability, speed, and scalability. We want our users to find Swarms intuitive and dependable, fast and adaptable to their needs. This philosophy guides all of our design and development decisions.
+
+# Swarm Architecture Design Document
+
+## Overview
+
+The goal of the Swarm Architecture is to provide a flexible and scalable system to build swarm intelligence models that can solve complex problems. This document details the proposed design to create a plug-and-play system, which makes it easy to create custom swarms, and provides pre-configured swarms with multi-modal agents.
+
+## Design Principles
+
+- **Modularity**: The system will be built in a modular fashion, allowing various components to be easily swapped or upgraded.
+- **Interoperability**: Different swarm classes and components should be able to work together seamlessly.
+- **Scalability**: The design should support the growth of the system by adding more components or swarms.
+- **Ease of Use**: Users should be able to easily create their own swarms or use pre-configured ones with minimal configuration.
+
+## Design Components
+
+### AbstractSwarm
+
+The AbstractSwarm is an abstract base class which defines the basic structure of a swarm and the methods that need to be implemented. Any new swarm should inherit from this class and implement the required methods.
+
+### Swarm Classes
+
+Various Swarm classes can be implemented inheriting from the AbstractSwarm class. Each swarm class should implement the required methods for initializing the components, worker nodes, and boss node, and running the swarm.
+
+Pre-configured swarm classes with multi-modal agents can be provided for ease of use. These classes come with a default configuration of tools and agents, which can be used out of the box.
+
+### Tools and Agents
+
+Tools and agents are the components that provide the actual functionality to the swarms. They can be language models, AI assistants, vector stores, or any other components that can help in problem solving.
+
+To make the system plug-and-play, a standard interface should be defined for these components. Any new tool or agent should implement this interface, so that it can be easily plugged into the system.
+
+## Usage
+
+Users can either use pre-configured swarms or create their own custom swarms.
+
+To use a pre-configured swarm, they can simply instantiate the corresponding swarm class and call the run method with the required objective.
+
+To create a custom swarm, they need to:
+
+1. Define a new swarm class inheriting from AbstractSwarm.
+2. Implement the required methods for the new swarm class.
+3. Instantiate the swarm class and call the run method.
+
+### Example
+
+```python
+# Using pre-configured swarm
+swarm = PreConfiguredSwarm(openai_api_key)
+swarm.run_swarms(objective)
+
+# Creating custom swarm
+class CustomSwarm(AbstractSwarm):
+    # Implement required methods
+
+swarm = CustomSwarm(openai_api_key)
+swarm.run_swarms(objective)
+```
+
+## Conclusion
+
+This Swarm Architecture design provides a scalable and flexible system for building swarm intelligence models. The plug-and-play design allows users to easily use pre-configured swarms or create their own custom swarms.
+
+
+# Swarming Architectures
+Sure, below are five different swarm architectures with their base requirements and an abstract class that processes these components:
+
+1. **Hierarchical Swarm**: This architecture is characterized by a boss/worker relationship. The boss node takes high-level decisions and delegates tasks to the worker nodes. The worker nodes perform tasks and report back to the boss node. 
+    - Requirements: Boss node (can be a large language model), worker nodes (can be smaller language models), and a task queue for task management.
+
+2. **Homogeneous Swarm**: In this architecture, all nodes in the swarm are identical and contribute equally to problem-solving. Each node has the same capabilities.
+    - Requirements: Homogeneous nodes (can be language models of the same size), communication protocol for nodes to share information.
+
+3. **Heterogeneous Swarm**: This architecture contains different types of nodes, each with its specific capabilities. This diversity can lead to more robust problem-solving.
+    - Requirements: Different types of nodes (can be different types and sizes of language models), a communication protocol, and a mechanism to delegate tasks based on node capabilities.
+
+4. **Competitive Swarm**: In this architecture, nodes compete with each other to find the best solution. The system may use a selection process to choose the best solutions.
+    - Requirements: Nodes (can be language models), a scoring mechanism to evaluate node performance, a selection mechanism.
+
+5. **Cooperative Swarm**: In this architecture, nodes work together and share information to find solutions. The focus is on cooperation rather than competition.
+    - Requirements: Nodes (can be language models), a communication protocol, a consensus mechanism to agree on solutions.
+
+
+6. **Grid-based Swarm**: This architecture positions agents on a grid, where they can only interact with their neighbors. This is useful for simulations, especially in fields like ecology or epidemiology.
+    - Requirements: Agents (can be language models), a grid structure, and a neighborhood definition (i.e., how to identify neighboring agents).
+
+7. **Particle Swarm Optimization (PSO) Swarm**: In this architecture, each agent represents a potential solution to an optimization problem. Agents move in the solution space based on their own and their neighbors' past performance. PSO is especially useful for continuous numerical optimization problems.
+    - Requirements: Agents (each representing a solution), a definition of the solution space, an evaluation function to rate the solutions, a mechanism to adjust agent positions based on performance.
+
+8. **Ant Colony Optimization (ACO) Swarm**: Inspired by ant behavior, this architecture has agents leave a pheromone trail that other agents follow, reinforcing the best paths. It's useful for problems like the traveling salesperson problem.
+    - Requirements: Agents (can be language models), a representation of the problem space, a pheromone updating mechanism.
+
+9. **Genetic Algorithm (GA) Swarm**: In this architecture, agents represent potential solutions to a problem. They can 'breed' to create new solutions and can undergo 'mutations'. GA swarms are good for search and optimization problems.
+    - Requirements: Agents (each representing a potential solution), a fitness function to evaluate solutions, a crossover mechanism to breed solutions, and a mutation mechanism.
+
+10. **Stigmergy-based Swarm**: In this architecture, agents communicate indirectly by modifying the environment, and other agents react to such modifications. It's a decentralized method of coordinating tasks.
+    - Requirements: Agents (can be language models), an environment that agents can modify, a mechanism for agents to perceive environment changes.
+
+These architectures all have unique features and requirements, but they share the need for agents (often implemented as language models) and a mechanism for agents to communicate or interact, whether it's directly through messages, indirectly through the environment, or implicitly through a shared solution space. Some also require specific data structures, like a grid or problem space, and specific algorithms, like for evaluating solutions or updating agent positions.

docs/distribution.md

@@ -0,0 +1,469 @@
+
+
+# Swarms Monetization Strategy 
+
+This strategy includes a variety of business models, potential revenue streams, cashflow structures, and customer identification methods. Let's explore these further.
+
+## Business Models 
+
+1. **Platform as a Service (PaaS):** Provide the Swarms AI platform on a subscription basis, charged monthly or annually. This could be tiered based on usage and access to premium features. 
+
+2. **API Usage-based Pricing:** Charge customers based on their usage of the Swarms API. The more requests made, the higher the fee.
+
+3. **Managed Services:** Offer complete end-to-end solutions where you manage the entire AI infrastructure for the clients. This could be on a contract basis with a recurring fee.
+
+4. **Training and Certification:** Provide Swarms AI training and certification programs for interested developers and businesses. These could be monetized as separate courses or subscription-based access.
+
+5. **Partnerships:** Collaborate with large enterprises and offer them dedicated Swarm AI services. These could be performance-based contracts, ensuring a mutually beneficial relationship.
+
+6. **Data as a Service (DaaS):** Leverage the data generated by Swarms for insights and analytics, providing valuable business intelligence to clients.
+
+## Potential Revenue Streams 
+
+1. **Subscription Fees:** This would be the main revenue stream from providing the Swarms platform as a service.
+
+2. **Usage Fees:** Additional revenue can come from usage fees for businesses that have high demand for Swarms API.
+
+3. **Contract Fees:** From offering managed services and bespoke solutions to businesses.
+
+4. **Training Fees:** Revenue from providing training and certification programs to developers and businesses.
+
+5. **Partnership Contracts:** Large-scale projects with enterprises, involving dedicated Swarm AI services, could provide substantial income.
+
+6. **Data Insights:** Revenue from selling valuable business intelligence derived from Swarm's aggregated and anonymized data.
+
+## Potential Customers 
+
+1. **Businesses Across Sectors:** Any business seeking to leverage AI for automation, efficiency, and data insights could be a potential customer. This includes sectors like finance, eCommerce, logistics, healthcare, and more.
+
+2. **Developers:** Both freelance and those working in organizations could use Swarms to enhance their projects and services. 
+
+3. **Enterprises:** Large enterprises looking to automate and optimize their operations could greatly benefit from Swarms.
+
+4. **Educational Institutions:** Universities and research institutions could leverage Swarms for research and teaching purposes.
+
+## Roadmap 
+
+1. **Landing Page Creation:** Develop a dedicated product page on apac.ai for Swarms.
+
+2. **Hosted Swarms API:** Launch a cloud-based Swarms API service. It should be highly reliable, with robust documentation to attract daily users.
+
+3. **Consumer and Enterprise Subscription Service:** Launch a comprehensive subscription service on The Domain. This would provide users with access to a wide array of APIs and data streams.
+
+4. **Dedicated Capacity Deals:** Partner with large enterprises to offer them dedicated Swarm AI solutions for automating their operations.
+
+5. **Enterprise Partnerships:** Develop partnerships with large enterprises for extensive contract-based projects.
+
+6. **Integration with Collaboration Platforms:** Develop Swarms bots for platforms like Discord and Slack, charging users a subscription fee for access.
+
+7. **Personal Data Instances:** Offer users dedicated instances of all their data that the Swarm can query as needed.
+
+8. **Browser Extension:** Develop a browser extension that integrates with the Swarms platform, offering users a more seamless experience.
+
+Remember, customer satisfaction and a value-centric approach are at the core of any successful monetization strategy. It's essential to continuously iterate and improve the product based on customer feedback and evolving market needs.
+
+----
+
+# Other ideas
+
+1. **Platform as a Service (PaaS):** Create a cloud-based platform that allows users to build, run, and manage applications without the complexity of maintaining the infrastructure. You could charge users a subscription fee for access to the platform and provide different pricing tiers based on usage levels. This could be an attractive solution for businesses that do not have the capacity to build or maintain their own swarm intelligence solutions.
+
+2. **Professional Services:** Offer consultancy and implementation services to businesses looking to utilize the Swarm technology. This could include assisting with integration into existing systems, offering custom development services, or helping customers to build specific solutions using the framework.
+
+3. **Education and Training:** Create a certification program for developers or companies looking to become proficient with the Swarms framework. This could be sold as standalone courses, or bundled with other services. 
+
+4. **Managed Services:** Some companies may prefer to outsource the management of their Swarm-based systems. A managed services solution could take care of all the technical aspects, from hosting the solution to ensuring it runs smoothly, allowing the customer to focus on their core business.
+
+5. **Data Analysis and Insights:** Swarm intelligence can generate valuable data and insights. By anonymizing and aggregating this data, you could provide industry reports, trend analysis, and other valuable insights to businesses.
+
+As for the type of platform, Swarms can be offered as a cloud-based solution given its scalability and flexibility. This would also allow you to apply a SaaS/PaaS type monetization model, which provides recurring revenue.
+
+Potential customers could range from small to large enterprises in various sectors such as logistics, eCommerce, finance, and technology, who are interested in leveraging artificial intelligence and machine learning for complex problem solving, optimization, and decision-making.
+
+**Product Brief Monetization Strategy:**
+
+Product Name: Swarms.AI Platform
+
+Product Description: A cloud-based AI and ML platform harnessing the power of swarm intelligence. 
+
+1. **Platform as a Service (PaaS):** Offer tiered subscription plans (Basic, Premium, Enterprise) to accommodate different usage levels and business sizes. 
+
+2. **Professional Services:** Offer consultancy and custom development services to tailor the Swarms solution to the specific needs of the business.
+
+3. **Education and Training:** Launch an online Swarms.AI Academy with courses and certifications for developers and businesses. 
+
+4. **Managed Services:** Provide a premium, fully-managed service offering that includes hosting, maintenance, and 24/7 support.
+
+5. **Data Analysis and Insights:** Offer industry reports and customized insights generated from aggregated and anonymized Swarm data.
+
+Potential Customers: Enterprises in sectors such as logistics, eCommerce, finance, and technology. This can be sold globally, provided there's an internet connection.
+
+Marketing Channels: Online marketing (SEO, Content Marketing, Social Media), Partnerships with tech companies, Direct Sales to Enterprises.
+
+This strategy is designed to provide multiple revenue streams, while ensuring the Swarms.AI platform is accessible and useful to a range of potential customers.
+
+1. **AI Solution as a Service:** By offering the Swarms framework as a service, businesses can access and utilize the power of multiple LLM agents without the need to maintain the infrastructure themselves. Subscription can be tiered based on usage and additional features.
+
+2. **Integration and Custom Development:** Offer integration services to businesses wanting to incorporate the Swarms framework into their existing systems. Also, you could provide custom development for businesses with specific needs not met by the standard framework.
+
+3. **Training and Certification:** Develop an educational platform offering courses, webinars, and certifications on using the Swarms framework. This can serve both developers seeking to broaden their skills and businesses aiming to train their in-house teams.
+
+4. **Managed Swarms Solutions:** For businesses that prefer to outsource their AI needs, provide a complete solution which includes the development, maintenance, and continuous improvement of swarms-based applications.
+
+5. **Data Analytics Services:** Leveraging the aggregated insights from the AI swarms, you could offer data analytics services. Businesses can use these insights to make informed decisions and predictions.
+
+**Type of Platform:**
+
+Cloud-based platform or Software as a Service (SaaS) will be a suitable model. It offers accessibility, scalability, and ease of updates. 
+
+**Target Customers:**
+
+The technology can be beneficial for businesses across sectors like eCommerce, technology, logistics, finance, healthcare, and education, among others.
+
+**Product Brief Monetization Strategy:**
+
+Product Name: Swarms.AI
+
+1. **AI Solution as a Service:** Offer different tiered subscriptions (Standard, Premium, and Enterprise) each with varying levels of usage and features.
+
+2. **Integration and Custom Development:** Offer custom development and integration services, priced based on the scope and complexity of the project.
+
+3. **Training and Certification:** Launch the Swarms.AI Academy with courses and certifications, available for a fee. 
+
+4. **Managed Swarms Solutions:** Offer fully managed solutions tailored to business needs, priced based on scope and service level agreements.
+
+5. **Data Analytics Services:** Provide insightful reports and data analyses, which can be purchased on a one-off basis or through a subscription.
+
+By offering a variety of services and payment models, Swarms.AI will be able to cater to a diverse range of business needs, from small start-ups to large enterprises. Marketing channels would include digital marketing, partnerships with technology companies, presence in tech events, and direct sales to targeted industries.
+
+
+
+# Roadmap
+
+* Create a landing page for swarms apac.ai/product/swarms
+
+* Create Hosted Swarms API for anybody to just use without need for mega gpu infra, charge usage based pricing. Prerequisites for success => Swarms has to be extremely reliable + we need world class documentation and many daily users => how do we get many daily users? We provide a seamless and fluid experience, how do we create a seamless and fluid experience? We write good code that is modular, provides feedback to the user in times of distress, and ultimately accomplishes the user's tasks.
+
+* Hosted consumer and enterprise subscription as a service on The Domain, where users can interact with 1000s of APIs and ingest 1000s of different data streams.
+
+* Hosted dedicated capacity deals with mega enterprises on automating many operations with Swarms for monthly subscription 300,000+$ 
+
+* Partnerships with enterprises, massive contracts with performance based fee
+
+* Have discord bot and or slack bot with users personal data, charge subscription + browser extension
+
+* each user gets a dedicated ocean instance of all their data so the swarm can query it as needed.
+
+
+
+
+---
+---
+
+
+# Swarms Monetization Strategy: A Revolutionary AI-powered Future
+
+Swarms is a powerful AI platform leveraging the transformative potential of Swarm Intelligence. Our ambition is to monetize this groundbreaking technology in ways that generate significant cashflow while providing extraordinary value to our customers. 
+
+Here we outline our strategic monetization pathways and provide a roadmap that plots our course to future success.
+
+---
+
+## I. Business Models
+
+1. **Platform as a Service (PaaS):** We provide the Swarms platform as a service, billed on a monthly or annual basis. Subscriptions can range from $50 for basic access, to $500+ for premium features and extensive usage.
+
+2. **API Usage-based Pricing:** Customers are billed according to their use of the Swarms API. Starting at $0.01 per request, this creates a cashflow model that rewards extensive platform usage.
+
+3. **Managed Services:** We offer end-to-end solutions, managing clients' entire AI infrastructure. Contract fees start from $100,000 per month, offering both a sustainable cashflow and considerable savings for our clients.
+
+4. **Training and Certification:** A Swarms AI training and certification program is available for developers and businesses. Course costs can range from $200 to $2,000, depending on course complexity and duration.
+
+5. **Partnerships:** We forge collaborations with large enterprises, offering dedicated Swarm AI services. These performance-based contracts start from $1,000,000, creating a potentially lucrative cashflow stream.
+
+6. **Data as a Service (DaaS):** Swarms generated data are mined for insights and analytics, with business intelligence reports offered from $500 each. 
+
+---
+
+## II. Potential Revenue Streams 
+
+1. **Subscription Fees:** From $50 to $500+ per month for platform access.
+
+2. **Usage Fees:** From $0.01 per API request, generating income from high platform usage.
+
+3. **Contract Fees:** Starting from $100,000 per month for managed services.
+
+4. **Training Fees:** From $200 to $2,000 for individual courses or subscription access.
+
+5. **Partnership Contracts:** Contracts starting from $100,000, offering major income potential.
+
+6. **Data Insights:** Business intelligence reports starting from $500.
+
+---
+
+## III. Potential Customers 
+
+1. **Businesses Across Sectors:** Our offerings cater to businesses across finance, eCommerce, logistics, healthcare, and more.
+
+2. **Developers:** Both freelancers and organization-based developers can leverage Swarms for their projects.
+
+3. **Enterprises:** Swarms offers large enterprises solutions for optimizing operations.
+
+4. **Educational Institutions:** Universities and research institutions can use Swarms for research and teaching.
+
+---
+
+## IV. Roadmap 
+
+1. **Landing Page Creation:** Develop a dedicated Swarms product page on apac.ai.
+
+2. **Hosted Swarms API:** Launch a reliable, well-documented cloud-based Swarms API service.
+
+3. **Consumer and Enterprise Subscription Service:** Launch an extensive subscription service on The Domain, providing wide-ranging access to APIs and data streams.
+
+4. **Dedicated Capacity Deals:** Offer large enterprises dedicated Swarm AI solutions, starting from $300,000 monthly subscription.
+
+5. **Enterprise Partnerships:** Develop performance-based contracts with large enterprises.
+
+6. **Integration with Collaboration Platforms:** Develop Swarms bots for platforms like Discord and Slack, charging a subscription fee for access.
+
+7. **Personal Data Instances:** Offer users dedicated data instances that the Swarm can query as needed.
+
+8. **Browser Extension:** Develop a browser extension that integrates with the Swarms platform for seamless user experience.
+
+---
+
+Our North Star remains customer satisfaction and value provision. 
+As we embark on this journey, we continuously refine our product based on customer feedback and evolving market needs, ensuring we lead in the age of AI-driven solutions.
+
+## **Platform Distribution Strategy for Swarms**
+
+*Note: This strategy aims to diversify the presence of 'Swarms' across various platforms and mediums while focusing on monetization and value creation for its users.
+
+---
+
+### **1. Framework:**
+
+#### **Objective:**
+To offer Swarms as an integrated solution within popular frameworks to ensure that developers and businesses can seamlessly incorporate its functionalities.
+
+#### **Strategy:**
+
+* **Language/Framework Integration:** 
+    * Target popular frameworks like Django, Flask for Python, Express.js for Node, etc. 
+    * Create SDKs or plugins for easy integration. 
+
+* **Monetization:** 
+    * Freemium Model: Offer basic integration for free, and charge for additional features or advanced integrations.
+    * Licensing: Allow businesses to purchase licenses for enterprise-level integrations.
+
+* **Promotion:**
+    * Engage in partnerships with popular online coding platforms like Udemy, Coursera, etc., offering courses and tutorials on integrating Swarms.
+    * Host webinars and write technical blogs to promote the integration benefits.
+
+---
+
+### **2. Paid API:**
+
+#### **Objective:**
+To provide a scalable solution for developers and businesses that want direct access to Swarms' functionalities without integrating the entire framework.
+
+#### **Strategy:**
+
+* **API Endpoints:**
+    * Offer various endpoints catering to different functionalities.
+    * Maintain robust documentation to ensure ease of use.
+
+* **Monetization:**
+    * Usage-based Pricing: Charge based on the number of API calls.
+    * Subscription Tiers: Provide tiered packages based on usage limits and advanced features.
+
+* **Promotion:**
+    * List on API marketplaces like RapidAPI.
+    * Engage in SEO to make the API documentation discoverable.
+
+---
+
+### **3. Domain Hosted:**
+
+#### **Objective:**
+To provide a centralized web platform where users can directly access and engage with Swarms' offerings.
+
+#### **Strategy:**
+
+* **User-Friendly Interface:**
+    * Ensure a seamless user experience with intuitive design.
+    * Incorporate features like real-time chat support, tutorials, and an FAQ section.
+
+* **Monetization:**
+    * Subscription Model: Offer monthly/annual subscriptions for premium features.
+    * Affiliate Marketing: Partner with related tech products/services and earn through referrals.
+
+* **Promotion:**
+    * Invest in PPC advertising on platforms like Google Ads.
+    * Engage in content marketing, targeting keywords related to Swarms' offerings.
+
+---
+
+### **4. Build Your Own (No-Code Platform):**
+
+#### **Objective:**
+To cater to the non-developer audience, allowing them to leverage Swarms' features without any coding expertise.
+
+#### **Strategy:**
+
+* **Drag-and-Drop Interface:**
+    * Offer customizable templates.
+    * Ensure integration with popular platforms and apps.
+
+* **Monetization:**
+    * Freemium Model: Offer basic features for free, and charge for advanced functionalities.
+    * Marketplace for Plugins: Allow third-party developers to sell their plugins/extensions on the platform.
+
+* **Promotion:**
+    * Partner with no-code communities and influencers.
+    * Offer promotions and discounts to early adopters.
+
+---
+
+### **5. Marketplace for the No-Code Platform:**
+
+#### **Objective:**
+To create an ecosystem where third-party developers can contribute, and users can enhance their Swarms experience.
+
+#### **Strategy:**
+
+* **Open API for Development:**
+    * Offer robust documentation and developer support.
+    * Ensure a strict quality check for marketplace additions.
+
+* **Monetization:**
+    * Revenue Sharing: Take a percentage cut from third-party sales.
+    * Featured Listings: Charge developers for premium listings.
+
+* **Promotion:**
+    * Host hackathons and competitions to boost developer engagement.
+    * Promote top plugins/extensions through email marketing and on the main platform.
+
+---
+
+### **Future Outlook & Expansion:**
+
+* **Hosted Dedicated Capacity:** Hosted dedicated capacity deals for enterprises starting at 399,999$
+* **Decentralized Free Peer to peer endpoint hosted on The Grid:** Hosted endpoint by the people for the people.
+* **Browser Extenision:** Athena browser extension for deep browser automation, subscription, usage, 
+
+
+* **Mobile Application:** Develop a mobile app version for Swarms to tap into the vast mobile user base.
+* **Global Expansion:** Localize the platform for non-English speaking regions to tap into global markets.
+* **Continuous Learning:** Regularly collect user feedback and iterate on the product features.
+
+---
+
+
+
+### **50 Creative Distribution Platforms for Swarms**
+
+1. **E-commerce Integrations:** Platforms like Shopify, WooCommerce, where Swarms can add value to sellers.
+ 
+2. **Web Browser Extensions:** Chrome, Firefox, and Edge extensions that bring Swarms features directly to users.
+
+3. **Podcasting Platforms:** Swarms-themed content on platforms like Spotify, Apple Podcasts to reach aural learners.
+
+4. **Virtual Reality (VR) Platforms:** Integration with VR experiences on Oculus or Viveport.
+
+5. **Gaming Platforms:** Tools or plugins for game developers on Steam, Epic Games.
+
+6. **Decentralized Platforms:** Using blockchain, create decentralized apps (DApps) versions of Swarms.
+
+7. **Chat Applications:** Integrate with popular messaging platforms like WhatsApp, Telegram, Slack.
+
+8. **AI Assistants:** Integration with Siri, Alexa, Google Assistant to provide Swarms functionalities via voice commands.
+
+9. **Freelancing Websites:** Offer tools or services for freelancers on platforms like Upwork, Fiverr.
+
+10. **Online Forums:** Platforms like Reddit, Quora, where users can discuss or access Swarms.
+
+11. **Educational Platforms:** Sites like Khan Academy, Udacity where Swarms can enhance learning experiences.
+
+12. **Digital Art Platforms:** Integrate with platforms like DeviantArt, Behance.
+
+13. **Open-source Repositories:** Hosting Swarms on GitHub, GitLab, Bitbucket with open-source plugins.
+
+14. **Augmented Reality (AR) Apps:** Create AR experiences powered by Swarms.
+
+15. **Smart Home Devices:** Integrate Swarms' functionalities into smart home devices.
+
+16. **Newsletters:** Platforms like Substack, where Swarms insights can be shared.
+
+17. **Interactive Kiosks:** In malls, airports, and other public places.
+
+18. **IoT Devices:** Incorporate Swarms in devices like smart fridges, smartwatches.
+
+19. **Collaboration Tools:** Platforms like Trello, Notion, offering Swarms-enhanced productivity.
+
+20. **Dating Apps:** An AI-enhanced matching algorithm powered by Swarms.
+
+21. **Music Platforms:** Integrate with Spotify, SoundCloud for music-related AI functionalities.
+
+22. **Recipe Websites:** Platforms like AllRecipes, Tasty with AI-recommended recipes.
+
+23. **Travel & Hospitality:** Integrate with platforms like Airbnb, Tripadvisor for AI-based recommendations.
+
+24. **Language Learning Apps:** Duolingo, Rosetta Stone integrations.
+
+25. **Virtual Events Platforms:** Websites like Hopin, Zoom where Swarms can enhance the virtual event experience.
+
+26. **Social Media Management:** Tools like Buffer, Hootsuite with AI insights by Swarms.
+
+27. **Fitness Apps:** Platforms like MyFitnessPal, Strava with AI fitness insights.
+
+28. **Mental Health Apps:** Integration into apps like Calm, Headspace for AI-driven wellness.
+
+29. **E-books Platforms:** Amazon Kindle, Audible with AI-enhanced reading experiences.
+
+30. **Sports Analysis Tools:** Websites like ESPN, Sky Sports where Swarms can provide insights.
+
+31. **Financial Tools:** Integration into platforms like Mint, Robinhood for AI-driven financial advice.
+
+32. **Public Libraries:** Digital platforms of public libraries for enhanced reading experiences.
+
+33. **3D Printing Platforms:** Websites like Thingiverse, Shapeways with AI customization.
+
+34. **Meme Platforms:** Websites like Memedroid, 9GAG where Swarms can suggest memes.
+
+35. **Astronomy Apps:** Platforms like Star Walk, NASA's Eyes with AI-driven space insights.
+
+36. **Weather Apps:** Integration into Weather.com, AccuWeather for predictive analysis.
+
+37. **Sustainability Platforms:** Websites like Ecosia, GoodGuide with AI-driven eco-tips.
+
+38. **Fashion Apps:** Platforms like ASOS, Zara with AI-based style recommendations.
+
+39. **Pet Care Apps:** Integration into PetSmart, Chewy for AI-driven pet care tips.
+
+40. **Real Estate Platforms:** Websites like Zillow, Realtor with AI-enhanced property insights.
+
+41. **DIY Platforms:** Websites like Instructables, DIY.org with AI project suggestions.
+
+42. **Genealogy Platforms:** Ancestry, MyHeritage with AI-driven family tree insights.
+
+43. **Car Rental & Sale Platforms:** Integration into AutoTrader, Turo for AI-driven vehicle suggestions.
+
+44. **Wedding Planning Websites:** Platforms like Zola, The Knot with AI-driven planning.
+
+45. **Craft Platforms:** Websites like Etsy, Craftsy with AI-driven craft suggestions.
+
+46. **Gift Recommendation Platforms:** AI-driven gift suggestions for websites like Gifts.com.
+
+47. **Study & Revision Platforms:** Websites like Chegg, Quizlet with AI-driven study guides.
+
+48. **Local Business Directories:** Yelp, Yellow Pages with AI-enhanced reviews.
+
+49. **Networking Platforms:** LinkedIn, Meetup with AI-driven connection suggestions.
+
+50. **Lifestyle Magazines' Digital Platforms:** Websites like Vogue, GQ with AI-curated fashion and lifestyle insights.
+
+---
+
+*Endnote: Leveraging these diverse platforms ensures that Swarms becomes an integral part of multiple ecosystems, enhancing its visibility and user engagement.*

docs/examples/count-tokens.md

@@ -0,0 +1,29 @@
+To count tokens you can use Swarms events and the `TokenCounter` util:
+
+```python
+from swarms import utils
+from swarms.events import (
+    StartPromptEvent, FinishPromptEvent,
+)
+from swarms.structures import Agent
+
+
+token_counter = utils.TokenCounter()
+
+agent = Agent(
+    event_listeners={
+        StartPromptEvent: [
+            lambda e: token_counter.add_tokens(e.token_count)
+        ],
+        FinishPromptEvent: [
+            lambda e: token_counter.add_tokens(e.token_count)
+        ],
+    }
+)
+
+agent.run("tell me about large language models")
+agent.run("tell me about GPT")
+
+print(f"total tokens: {token_counter.tokens}")
+
+```

docs/examples/index.md

@@ -0,0 +1,3 @@
+This section of the documentation is dedicated to examples highlighting Swarms functionality.
+
+We try to keep all examples up to date, but if you think there is a bug please [submit a pull request](https://github.com/kyegomez/swarms-docs/tree/main/docs/examples). We are also more than happy to include new examples :)