mistral caller, openai verison 2.8, llama function caller, tests for …

…flow

.gitignore

@@ -24,6 +24,7 @@ stderr_log.txt
 __pycache__/
 *.py[cod]
 *$py.class
+.grit
 error.txt
 
 # C extensions

README.md

@@ -74,10 +74,7 @@ flow = Flow(
 # out = flow.load_state("flow_state.json")
 # temp = flow.dynamic_temperature()
 # filter = flow.add_response_filter("Trump")
-
-# Run the flow
 out = flow.run("Generate a 10,000 word blog on health and wellness.")
-
 # out = flow.validate_response(out)
 # out = flow.analyze_feedback(out)
 # out = flow.print_history_and_memory()
@@ -138,6 +135,77 @@ for task in workflow.tasks:
 
 ---
 
+# Features 🤖 
+The Swarms framework is designed with a strong emphasis on reliability, performance, and production-grade readiness. 
+Below are the key features that make Swarms an ideal choice for enterprise-level AI deployments.
+
+## 🚀 Production-Grade Readiness
+- **Scalable Architecture**: Built to scale effortlessly with your growing business needs.
+- **Enterprise-Level Security**: Incorporates top-notch security features to safeguard your data and operations.
+- **Containerization and Microservices**: Easily deployable in containerized environments, supporting microservices architecture.
+
+## ⚙️ Reliability and Robustness
+- **Fault Tolerance**: Designed to handle failures gracefully, ensuring uninterrupted operations.
+- **Consistent Performance**: Maintains high performance even under heavy loads or complex computational demands.
+- **Automated Backup and Recovery**: Features automatic backup and recovery processes, reducing the risk of data loss.
+
+## 💡 Advanced AI Capabilities
+
+The Swarms framework is equipped with a suite of advanced AI capabilities designed to cater to a wide range of applications and scenarios, ensuring versatility and cutting-edge performance.
+
+### Multi-Modal Autonomous Agents
+- **Versatile Model Support**: Seamlessly works with various AI models, including NLP, computer vision, and more, for comprehensive multi-modal capabilities.
+- **Context-Aware Processing**: Employs context-aware processing techniques to ensure relevant and accurate responses from agents.
+
+### Function Calling Models for API Execution
+- **Automated API Interactions**: Function calling models that can autonomously execute API calls, enabling seamless integration with external services and data sources.
+- **Dynamic Response Handling**: Capable of processing and adapting to responses from APIs for real-time decision making.
+
+### Varied Architectures of Swarms
+- **Flexible Configuration**: Supports multiple swarm architectures, from centralized to decentralized, for diverse application needs.
+- **Customizable Agent Roles**: Allows customization of agent roles and behaviors within the swarm to optimize performance and efficiency.
+
+### Generative Models
+- **Advanced Generative Capabilities**: Incorporates state-of-the-art generative models to create content, simulate scenarios, or predict outcomes.
+- **Creative Problem Solving**: Utilizes generative AI for innovative problem-solving approaches and idea generation.
+
+### Enhanced Decision-Making
+- **AI-Powered Decision Algorithms**: Employs advanced algorithms for swift and effective decision-making in complex scenarios.
+- **Risk Assessment and Management**: Capable of assessing risks and managing uncertain situations with AI-driven insights.
+
+### Real-Time Adaptation and Learning
+- **Continuous Learning**: Agents can continuously learn and adapt from new data, improving their performance and accuracy over time.
+- **Environment Adaptability**: Designed to adapt to different operational environments, enhancing robustness and reliability.
+
+
+## 🔄 Efficient Workflow Automation
+- **Streamlined Task Management**: Simplifies complex tasks with automated workflows, reducing manual intervention.
+- **Customizable Workflows**: Offers customizable workflow options to fit specific business needs and requirements.
+- **Real-Time Analytics and Reporting**: Provides real-time insights into agent performance and system health.
+
+## 🌐 Wide-Ranging Integration
+- **API-First Design**: Easily integrates with existing systems and third-party applications via robust APIs.
+- **Cloud Compatibility**: Fully compatible with major cloud platforms for flexible deployment options.
+- **Continuous Integration/Continuous Deployment (CI/CD)**: Supports CI/CD practices for seamless updates and deployment.
+
+## 📊 Performance Optimization
+- **Resource Management**: Efficiently manages computational resources for optimal performance.
+- **Load Balancing**: Automatically balances workloads to maintain system stability and responsiveness.
+- **Performance Monitoring Tools**: Includes comprehensive monitoring tools for tracking and optimizing performance.
+
+## 🛡️ Security and Compliance
+- **Data Encryption**: Implements end-to-end encryption for data at rest and in transit.
+- **Compliance Standards Adherence**: Adheres to major compliance standards ensuring legal and ethical usage.
+- **Regular Security Updates**: Regular updates to address emerging security threats and vulnerabilities.
+
+## 💬 Community and Support
+- **Extensive Documentation**: Detailed documentation for easy implementation and troubleshooting.
+- **Active Developer Community**: A vibrant community for sharing ideas, solutions, and best practices.
+- **Professional Support**: Access to professional support for enterprise-level assistance and guidance.
+
+Swarms framework is not just a tool but a robust, scalable, and secure partner in your AI journey, ready to tackle the challenges of modern AI applications in a business environment.
+
+
 ## Documentation
 - For documentation, go here, [swarms.apac.ai](https://swarms.apac.ai)
 

example.py

@@ -1,7 +1,7 @@
 from swarms.models import OpenAIChat
 from swarms.structs import Flow
 
-api_key = ""
+api_key = "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"
 
 # Initialize the language model, this model can be swapped out with Anthropic, ETC, Huggingface Models like Mistral, ETC
 llm = OpenAIChat(

playground/models/dall3.py

@@ -1,8 +1,6 @@
 from swarms.models import Dalle3
 
-dalle3 = Dalle3(
-    openai_api_key=""
-)
+dalle3 = Dalle3(openai_api_key="")
 task = "A painting of a dog"
 image_url = dalle3(task)
-print(image_url)
+print(image_url)

pyproject.toml

@@ -45,6 +45,7 @@ wget = "*"
 griptape = "*"
 httpx = "*"
 tiktoken = "*"
+safetensors = "*"
 attrs = "*"
 ggl = "*"
 ratelimit = "*"

requirements.txt

@@ -48,6 +48,7 @@ opencv-python-headless
 imageio-ffmpeg
 invisible-watermark
 kornia
+safetensors
 numpy
 omegaconf
 open_clip_torch

swarms/artifacts/main.py

@@ -10,6 +10,20 @@ class Artifact(BaseModel):
     """
 
     Artifact that has the task has been produced
+
+    Attributes:
+    -----------
+
+    artifact_id: str
+        ID of the artifact
+
+    file_name: str
+        Filename of the artifact
+
+    relative_path: str
+        Relative path of the artifact
+
+
     """
 
     artifact_id: StrictStr = Field(..., description="ID of the artifact")

swarms/memory/pg.py

@@ -2,7 +2,7 @@
 from typing import Optional
 from attr import define, field, Factory
 from dataclasses import dataclass
-from swarms.memory.vector_stores.base import BaseVectorStore
+from swarms.memory.base import BaseVectorStore
 from sqlalchemy.engine import Engine
 from sqlalchemy import create_engine, Column, String, JSON
 from sqlalchemy.ext.declarative import declarative_base

swarms/models/__init__.py

@@ -6,20 +6,21 @@
 # LLMs
 from swarms.models.anthropic import Anthropic  # noqa: E402
 from swarms.models.petals import Petals  # noqa: E402
-from swarms.models.mistral import Mistral # noqa: E402
-from swarms.models.openai_models import OpenAI, AzureOpenAI, OpenAIChat # noqa: E402
-from swarms.models.zephyr import Zephyr # noqa: E402
-from swarms.models.biogpt import BioGPT # noqa: E402
-from swarms.models.huggingface import HuggingfaceLLM # noqa: E402
-from swarms.models.wizard_storytelling import WizardLLMStoryTeller # noqa: E402
-from swarms.models.mpt import MPT7B # noqa: E402
+from swarms.models.mistral import Mistral  # noqa: E402
+from swarms.models.openai_models import OpenAI, AzureOpenAI, OpenAIChat  # noqa: E402
+from swarms.models.zephyr import Zephyr  # noqa: E402
+from swarms.models.biogpt import BioGPT  # noqa: E402
+from swarms.models.huggingface import HuggingfaceLLM  # noqa: E402
+from swarms.models.wizard_storytelling import WizardLLMStoryTeller  # noqa: E402
+from swarms.models.mpt import MPT7B  # noqa: E402
 
 # MultiModal Models
-from swarms.models.idefics import Idefics # noqa: E402
-from swarms.models.kosmos_two import Kosmos # noqa: E402
-from swarms.models.vilt import Vilt # noqa: E402
-from swarms.models.nougat import Nougat # noqa: E402
-from swarms.models.layoutlm_document_qa import LayoutLMDocumentQA # noqa: E402
+from swarms.models.idefics import Idefics  # noqa: E402
+from swarms.models.kosmos_two import Kosmos  # noqa: E402
+from swarms.models.vilt import Vilt  # noqa: E402
+from swarms.models.nougat import Nougat  # noqa: E402
+from swarms.models.layoutlm_document_qa import LayoutLMDocumentQA  # noqa: E402
+
 # from swarms.models.gpt4v import GPT4Vision
 # from swarms.models.dalle3 import Dalle3
 # from swarms.models.distilled_whisperx import DistilWhisperModel # noqa: E402

swarms/models/dalle3.py

@@ -1,11 +1,11 @@
-
 import concurrent.futures
 import logging
 import os
 import uuid
 from dataclasses import dataclass
 from io import BytesIO
 from typing import List
+
 import backoff
 import openai
 import requests

swarms/models/fuyu.py

@@ -75,13 +75,11 @@ def __call__(self, text: str, img: str):
 
     def get_img_from_web(self, img_url: str):
         """Get the image from the web"""
-        try:        
+        try:
             response = requests.get(img_url)
             response.raise_for_status()
             image_pil = Image.open(BytesIO(response.content))
             return image_pil
         except requests.RequestException as error:
             print(f"Error fetching image from {img_url} and error: {error}")
             return None
-
-

swarms/models/huggingface.py

@@ -1,9 +1,13 @@
+import asyncio
+import concurrent.futures
 import logging
+from typing import List, Tuple
+
 
 import torch
+from termcolor import colored
 from torch.nn.parallel import DistributedDataParallel as DDP
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-from termcolor import colored
 
 
 class HuggingfaceLLM:
@@ -43,6 +47,12 @@ def __init__(
         # logger=None,
         distributed=False,
         decoding=False,
+        max_workers: int = 5,
+        repitition_penalty: float = 1.3,
+        no_repeat_ngram_size: int = 5,
+        temperature: float = 0.7,
+        top_k: int = 40,
+        top_p: float = 0.8,
         *args,
         **kwargs,
     ):
@@ -56,6 +66,14 @@ def __init__(
         self.distributed = distributed
         self.decoding = decoding
         self.model, self.tokenizer = None, None
+        self.quantize = quantize
+        self.quantization_config = quantization_config
+        self.max_workers = max_workers
+        self.repitition_penalty = repitition_penalty
+        self.no_repeat_ngram_size = no_repeat_ngram_size
+        self.temperature = temperature
+        self.top_k = top_k
+        self.top_p = top_p
 
         if self.distributed:
             assert (
@@ -91,6 +109,10 @@ def print_error(self, error: str):
         """Print error"""
         print(colored(f"Error: {error}", "red"))
 
+    async def async_run(self, task: str):
+        """Ashcnronous generate text for a given prompt"""
+        return await asyncio.to_thread(self.run, task)
+
     def load_model(self):
         """Load the model"""
         if not self.model or not self.tokenizer:
@@ -113,6 +135,21 @@ def load_model(self):
                 self.logger.error(f"Failed to load the model or the tokenizer: {error}")
                 raise
 
+    def concurrent_run(self, tasks: List[str], max_workers: int = 5):
+        """Concurrently generate text for a list of prompts."""
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            results = list(executor.map(self.run, tasks))
+        return results
+
+    def run_batch(self, tasks_images: List[Tuple[str, str]]) -> List[str]:
+        """Process a batch of tasks and images"""
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self.run, task, img) for task, img in tasks_images
+            ]
+            results = [future.result() for future in futures]
+        return results
+
     def run(self, task: str):
         """
         Generate a response based on the prompt text.
@@ -175,29 +212,6 @@ def run(self, task: str):
             )
             raise
 
-    async def run_async(self, task: str, *args, **kwargs) -> str:
-        """
-        Run the model asynchronously
-
-        Args:
-            task (str): Task to run.
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
-
-        Examples:
-        >>> mpt_instance = MPT('mosaicml/mpt-7b-storywriter', "EleutherAI/gpt-neox-20b", max_tokens=150)
-        >>> mpt_instance("generate", "Once upon a time in a land far, far away...")
-        'Once upon a time in a land far, far away...'
-        >>> mpt_instance.batch_generate(["In the deep jungles,", "At the heart of the city,"], temperature=0.7)
-        ['In the deep jungles,',
-        'At the heart of the city,']
-        >>> mpt_instance.freeze_model()
-        >>> mpt_instance.unfreeze_model()
-
-        """
-        # Wrapping synchronous calls with async
-        return self.run(task, *args, **kwargs)
-
     def __call__(self, task: str):
         """
         Generate a response based on the prompt text.