swarms 7.5.2__py3-none-any.whl → 7.5.5__py3-none-any.whl

swarms/agents/reasoning_duo.py

@@ -0,0 +1,109 @@
+from typing import List
+
+from loguru import logger
+
+from swarms.prompts.reasoning_prompt import REASONING_PROMPT
+from swarms.structs.agent import Agent
+from swarms.structs.output_types import OutputType
+from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+
+
+class ReasoningDuo:
+    """
+    ReasoningDuo is a class that encapsulates the functionality of two agents: a reasoning agent and a main agent.
+
+    Attributes:
+        model_name (str): The name of the model used for the reasoning agent.
+        description (str): A description of the reasoning agent.
+        model_names (list[str]): A list of model names for the agents.
+        system_prompt (str): The system prompt for the main agent.
+        reasoning_agent (Agent): An instance of the Agent class for reasoning tasks.
+        main_agent (Agent): An instance of the Agent class for main tasks.
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "reasoning-agent-01",
+        agent_description: str = "A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
+        model_name: str = "gpt-4o-mini",
+        description: str = "A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
+        model_names: list[str] = ["gpt-4o-mini", "gpt-4o"],
+        system_prompt: str = "You are a helpful assistant that can answer questions and help with tasks.",
+        output_type: OutputType = "dict",
+    ):
+        self.agent_name = agent_name
+        self.agent_description = agent_description
+        self.model_name = model_name
+        self.description = description
+        self.output_type = output_type
+        self.reasoning_agent = Agent(
+            agent_name="Your",
+            description="A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
+            system_prompt=REASONING_PROMPT,
+            max_loops=1,
+            model_name=model_names[0],
+            dynamic_temperature_enabled=True,
+        )
+
+        self.main_agent = Agent(
+            agent_name=self.agent_name,
+            description=self.agent_description,
+            system_prompt=system_prompt,
+            max_loops=1,
+            model_name=model_names[1],
+            dynamic_temperature_enabled=True,
+        )
+
+        self.conversation = Conversation()
+
+    def run(self, task: str):
+        """
+        Executes the reasoning and main agents on the provided task.
+
+        Args:
+            task (str): The task to be processed by the agents.
+
+        Returns:
+            str: The output from the main agent after processing the task.
+        """
+        logger.info(f"Running task: {task}")
+
+        self.conversation.add(role="user", content=task)
+
+        output_reasoner = self.reasoning_agent.run(task)
+
+        self.conversation.add(
+            role=self.reasoning_agent.agent_name,
+            content=output_reasoner,
+        )
+
+        prompt = f"Task: {task} \n\n Your thoughts: {output_reasoner}"
+
+        output_main = self.main_agent.run(prompt)
+
+        self.conversation.add(
+            role=self.main_agent.agent_name, content=output_main
+        )
+
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
+
+    def batched_run(self, tasks: List[str]):
+        """
+        Executes the run method for a list of tasks.
+
+        Args:
+            tasks (list[str]): A list of tasks to be processed.
+
+        Returns:
+            list: A list of outputs from the main agent for each task.
+        """
+        outputs = []
+        for task in tasks:
+            logger.info(f"Processing task: {task}")
+            outputs.append(self.run(task))
+        return outputs

swarms/prompts/reasoning_prompt.py

@@ -0,0 +1,9 @@
+REASONING_PROMPT = """
+This is a structured conversation between the User and the Assistant, where the User poses a question, and the Assistant is tasked with providing a comprehensive solution. 
+
+Before delivering the final answer, the Assistant must engage in a thorough reasoning process. This involves critically analyzing the question, considering various perspectives, and evaluating potential solutions. The Assistant should articulate this reasoning process clearly, allowing the User to understand the thought process behind the answer.
+
+The reasoning process and the final answer should be distinctly enclosed within <think> </think> tags. For example, the format should be: <think> reasoning process here </think> for the reasoning, followed by <think> final answer here </think> for the answer. 
+
+It is essential to output multiple <think> </think> tags to reflect the depth of thought and exploration involved in addressing the task. The Assistant should strive to think deeply and thoroughly about the question, ensuring that all relevant aspects are considered before arriving at a conclusion.
+"""

swarms/structs/__init__.py

@@ -83,6 +83,8 @@ from swarms.structs.swarms_api import (
     SwarmValidationError,
 )
 
+from swarms.structs.de_hallucination_swarm import DeHallucinationSwarm
+
 __all__ = [
     "Agent",
     "AsyncWorkflow",
@@ -156,4 +158,5 @@ __all__ = [
     "AgentInput",
     "AgentsBuilder",
     "MALT",
+    "DeHallucinationSwarm",
 ]

swarms/structs/agent.py

@@ -579,23 +579,31 @@ class Agent:
         # Telemetry Processor to log agent data
         log_agent_data(self.to_dict())
 
-        if self.llm is None and self.model_name is not None:
+        if self.llm is None:
             self.llm = self.llm_handling()
 
     def llm_handling(self):
         from swarms.utils.litellm_wrapper import LiteLLM
 
-        if self.llm_args is not None:
-            llm = LiteLLM(model_name=self.model_name, **self.llm_args)
-
-        else:
-            llm = LiteLLM(
-                model_name=self.model_name,
-                temperature=self.temperature,
-                max_tokens=self.max_tokens,
-            )
+        if self.model_name is None:
+            raise ValueError("Model name cannot be None")
 
-        return llm
+        try:
+            if self.llm_args is not None:
+                llm = LiteLLM(
+                    model_name=self.model_name, **self.llm_args
+                )
+            else:
+                llm = LiteLLM(
+                    model_name=self.model_name,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    system_prompt=self.system_prompt,
+                )
+            return llm
+        except Exception as e:
+            logger.error(f"Error in llm_handling: {e}")
+            return None
 
     def prepare_tools_list_dictionary(self):
         import json
@@ -1064,13 +1072,13 @@ class Agent:
                 self.short_memory.get_str()
             )
 
-            # Handle artifacts
-            if self.artifacts_on is True:
-                self.handle_artifacts(
-                    concat_strings(all_responses),
-                    self.artifacts_output_path,
-                    self.artifacts_file_extension,
-                )
+            # # Handle artifacts
+            # if self.artifacts_on is True:
+            #     self.handle_artifacts(
+            #         concat_strings(all_responses),
+            #         self.artifacts_output_path,
+            #         self.artifacts_file_extension,
+            # )
 
             log_agent_data(self.to_dict())
             if self.autosave is True:
@@ -2413,11 +2421,11 @@ class Agent:
         if not isinstance(task, str):
             raise TypeError("Task must be a string")
 
-        if not task.strip():
-            raise ValueError("Task cannot be empty")
+        if task is None:
+            raise ValueError("Task cannot be None")
 
-        if self.llm is None:
-            raise TypeError("LLM object cannot be None")
+        # if self.llm is None:
+        #     raise TypeError("LLM object cannot be None")
 
         try:
             out = self.llm.run(task, *args, **kwargs)

swarms/structs/conversation.py

@@ -5,8 +5,9 @@ from typing import Any, Optional, Union
 import yaml
 from swarms.structs.base_structure import BaseStructure
 from typing import TYPE_CHECKING
+from swarms.utils.any_to_str import any_to_str
 from swarms.utils.formatter import formatter
-
+from swarms.utils.litellm_tokenizer import count_tokens
 
 if TYPE_CHECKING:
     from swarms.structs.agent import (
@@ -79,6 +80,7 @@ class Conversation(BaseStructure):
         auto_save: bool = True,
         save_as_yaml: bool = True,
         save_as_json_bool: bool = False,
+        token_count: bool = True,
         *args,
         **kwargs,
     ):
@@ -96,6 +98,7 @@ class Conversation(BaseStructure):
         self.auto_save = auto_save
         self.save_as_yaml = save_as_yaml
         self.save_as_json_bool = save_as_json_bool
+        self.token_count = token_count
 
         # If system prompt is not None, add it to the conversation history
         if self.system_prompt is not None:
@@ -128,17 +131,21 @@ class Conversation(BaseStructure):
         now = datetime.datetime.now()
         timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
 
+        tokens = count_tokens(any_to_str(content))
+
         if isinstance(content, dict) or isinstance(content, list):
 
             message = {
                 "role": role,
                 "content": content,
+                "token_count": int(tokens),
             }
 
         else:
             message = {
                 "role": role,
-                "content": f"Time: {timestamp} \n{content}",
+                "content": f"Time: {timestamp} \n {content}",
+                "token_count": int(tokens),
             }
 
         self.conversation_history.append(message)
@@ -448,16 +455,17 @@ class Conversation(BaseStructure):
 
 # # Example usage
 # # conversation = Conversation()
-# conversation = Conversation()
+# conversation = Conversation(token_count=True)
 # conversation.add("user", "Hello, how are you?")
-# conversation.add(
-#     "assistant", {"name": "tool_1", "output": "Hello, how are you?"}
-# )
-# print(conversation.return_json())
+# conversation.add("assistant", "I am doing well, thanks.")
+# # conversation.add(
+# #     "assistant", {"name": "tool_1", "output": "Hello, how are you?"}
+# # )
+# # print(conversation.return_json())
 
-# # print(conversation.get_last_message_as_string())
-# # print(conversation.return_messages_as_list())
-# # conversation.add("assistant", "I am doing well, thanks.")
-# # # print(conversation.to_json())
+# # # print(conversation.get_last_message_as_string())
+# print(conversation.return_json())
+# # # conversation.add("assistant", "I am doing well, thanks.")
+# # # # print(conversation.to_json())
 # # print(type(conversation.to_dict()))
 # # print(conversation.to_yaml())

swarms/structs/de_hallucination_swarm.py

@@ -0,0 +1,273 @@
+from typing import List, Dict, Any, Optional
+import time
+from loguru import logger
+from swarms.structs.agent import Agent
+
+# Prompt templates for different agent roles
+GENERATOR_PROMPT = """You are a knowledgeable assistant tasked with providing accurate information on a wide range of topics.
+
+Your responsibilities:
+1. Provide accurate information based on your training data
+2. Use clear, concise language
+3. Acknowledge limitations in your knowledge
+4. Abstain from making up information when uncertain
+
+When responding to queries:
+- Stick to verified facts
+- Cite your sources when possible
+- Clearly distinguish between firmly established facts and more tentative claims
+- Use phrases like "I'm not certain about..." or "Based on my knowledge up to my training cutoff..." when appropriate
+- Avoid overly confident language for uncertain topics
+
+Remember, it's better to acknowledge ignorance than to provide incorrect information.
+"""
+
+CRITIC_PROMPT = """You are a critical reviewer tasked with identifying potential inaccuracies, hallucinations, or unsupported claims in AI-generated text.
+
+Your responsibilities:
+1. Carefully analyze the provided text for factual errors
+2. Identify claims that lack sufficient evidence
+3. Spot logical inconsistencies
+4. Flag overly confident language on uncertain topics
+5. Detect potentially hallucinated details (names, dates, statistics, etc.)
+
+For each issue detected, you should:
+- Quote the specific problematic text
+- Explain why it's potentially inaccurate
+- Rate the severity of the issue (low/medium/high)
+- Suggest a specific correction or improvement
+
+Focus particularly on:
+- Unfounded claims presented as facts
+- Highly specific details that seem suspicious
+- Logical contradictions
+- Anachronisms or temporal inconsistencies
+- Claims that contradict common knowledge
+
+Be thorough and specific in your critique. Provide actionable feedback for improvement.
+"""
+
+REFINER_PROMPT = """You are a refinement specialist tasked with improving text based on critical feedback.
+
+Your responsibilities:
+1. Carefully review the original text and the critical feedback
+2. Make precise modifications to address all identified issues
+3. Ensure factual accuracy in the refined version
+4. Maintain the intended tone and style of the original
+5. Add appropriate epistemic status markers (e.g., "likely", "possibly", "according to...")
+
+Guidelines for refinement:
+- Remove or qualify unsupported claims
+- Replace specific details with more general statements when evidence is lacking
+- Add appropriate hedging language where certainty is not warranted
+- Maintain the helpful intent of the original response
+- Ensure logical consistency throughout the refined text
+- Add qualifiers or clarify knowledge limitations where appropriate
+
+The refined text should be helpful and informative while being scrupulously accurate.
+"""
+
+VALIDATOR_PROMPT = """You are a validation expert tasked with ensuring the highest standards of accuracy in refined AI outputs.
+
+Your responsibilities:
+1. Verify that all critical issues from previous feedback have been properly addressed
+2. Check for any remaining factual inaccuracies or unsupported claims
+3. Ensure appropriate epistemic status markers are used
+4. Confirm the response maintains a helpful tone while being accurate
+5. Provide a final assessment of the response quality
+
+Assessment structure:
+- Issue resolution: Have all previously identified issues been addressed? (Yes/No/Partially)
+- Remaining concerns: Are there any remaining factual or logical issues? (List if any)
+- Epistemics: Does the response appropriately indicate confidence levels? (Yes/No/Needs improvement)
+- Helpfulness: Does the response remain helpful despite necessary qualifications? (Yes/No/Partially)
+- Overall assessment: Final verdict on whether the response is ready for user consumption (Approved/Needs further refinement)
+
+If approved, explain what makes this response trustworthy. If further refinement is needed, provide specific guidance.
+"""
+
+
+class DeHallucinationSwarm:
+    """
+    A system of multiple agents that work together to reduce hallucinations in generated content.
+    The system works through multiple rounds of generation, criticism, refinement, and validation.
+    """
+
+    def __init__(
+        self,
+        name: str = "DeHallucinationSwarm",
+        description: str = "A system of multiple agents that work together to reduce hallucinations in generated content.",
+        model_names: List[str] = [
+            "gpt-4o-mini",
+            "gpt-4o-mini",
+            "gpt-4o-mini",
+            "gpt-4o-mini",
+        ],
+        iterations: int = 2,
+        system_prompt: str = GENERATOR_PROMPT,
+        store_intermediate_results: bool = True,
+    ):
+        """
+        Initialize the DeHallucinationSwarm with configurable agents.
+
+        Args:
+            model_names: List of model names for generator, critic, refiner, and validator
+            iterations: Number of criticism-refinement cycles to perform
+            store_intermediate_results: Whether to store all intermediate outputs
+        """
+        self.name = name
+        self.description = description
+        self.iterations = iterations
+        self.store_intermediate_results = store_intermediate_results
+        self.system_prompt = system_prompt
+        self.history = []
+
+        # Initialize all agents
+        self.generator = Agent(
+            agent_name="Generator",
+            description="An agent that generates initial responses to queries",
+            system_prompt=GENERATOR_PROMPT,
+            model_name=model_names[0],
+        )
+
+        self.critic = Agent(
+            agent_name="Critic",
+            description="An agent that critiques responses for potential inaccuracies",
+            system_prompt=CRITIC_PROMPT,
+            model_name=model_names[1],
+        )
+
+        self.refiner = Agent(
+            agent_name="Refiner",
+            description="An agent that refines responses based on critique",
+            system_prompt=REFINER_PROMPT,
+            model_name=model_names[2],
+        )
+
+        self.validator = Agent(
+            agent_name="Validator",
+            description="An agent that performs final validation of refined content",
+            system_prompt=VALIDATOR_PROMPT,
+            model_name=model_names[3],
+        )
+
+    def _log_step(
+        self,
+        step_name: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        """Record a step in the swarm's processing history"""
+        if self.store_intermediate_results:
+            timestamp = time.time()
+            step_record = {
+                "timestamp": timestamp,
+                "step": step_name,
+                "content": content,
+            }
+            if metadata:
+                step_record["metadata"] = metadata
+
+            self.history.append(step_record)
+            logger.debug(f"Logged step: {step_name}")
+
+    def run(self, query: str) -> Dict[str, Any]:
+        """
+        Process a query through the swarm's multi-agent refinement cycle.
+
+        Args:
+            query: The user's query to process
+
+        Returns:
+            Dict containing the final response and processing metadata
+        """
+        logger.info(f"Processing query: {query}")
+        self.history = []  # Reset history for new query
+
+        # Generate initial response
+        initial_response = self.generator.run(query)
+        self._log_step(
+            "initial_generation", initial_response, {"query": query}
+        )
+
+        current_response = initial_response
+
+        # Perform multiple iteration cycles
+        for i in range(self.iterations):
+            logger.info(f"Starting iteration {i+1}/{self.iterations}")
+
+            # Step 1: Critique the current response
+            critique = self.critic.run(
+                f"Review the following response to the query: '{query}'\n\n{current_response}"
+            )
+            self._log_step(f"critique_{i+1}", critique)
+
+            # Step 2: Refine based on critique
+            refined_response = self.refiner.run(
+                f"Refine the following response based on the critique provided.\n\n"
+                f"Original query: {query}\n\n"
+                f"Original response: {current_response}\n\n"
+                f"Critique: {critique}"
+            )
+            self._log_step(f"refinement_{i+1}", refined_response)
+
+            # Update current response for next iteration
+            current_response = refined_response
+
+        # Final validation
+        validation = self.validator.run(
+            f"Validate the following refined response for accuracy and helpfulness.\n\n"
+            f"Original query: {query}\n\n"
+            f"Final response: {current_response}"
+        )
+        self._log_step("final_validation", validation)
+
+        # Prepare results
+        result = {
+            "query": query,
+            "final_response": current_response,
+            "validation_result": validation,
+            "iteration_count": self.iterations,
+        }
+
+        if self.store_intermediate_results:
+            result["processing_history"] = self.history
+
+        return result
+
+    def batch_run(self, queries: List[str]) -> List[Dict[str, Any]]:
+        """
+        Process multiple queries through the swarm.
+
+        Args:
+            queries: List of user queries to process
+
+        Returns:
+            List of result dictionaries, one per query
+        """
+        results = []
+        for query in queries:
+            logger.info(f"Processing batch query: {query}")
+            results.append(self.run(query))
+        return results
+
+
+# # Example usage
+# if __name__ == "__main__":
+#     # Configure logger
+#     logger.add("dehallucinationswarm.log", rotation="10 MB")
+
+#     # Create swarm instance
+#     swarm = DeHallucinationSwarm(iterations=2)
+
+#     # Example queries that might tempt hallucination
+#     test_queries = [
+#         "Tell me about the history of quantum computing",
+#         "What are the specific details of the Treaty of Utrecht?",
+#         "Who won the Nobel Prize in Physics in 2020?",
+#         "What are the main causes of the economic recession of 2008?",
+#     ]
+
+#     # Process batch of queries
+#     results = swarm.batch_run(test_queries)
+#     print(results)

swarms/structs/malt.py

@@ -13,7 +13,7 @@ Potential Improvements:
 - Autonomously create the agents based on the task.
 - Feed verifier responses back into the creator to improve the proof.
 - Feed refiner responses back into the creator to improve the proof.
-- 
+- Feed majority voting responses back into the creator to improve the proof.
 
 
 This is a simplified implementation of the MALT orchestrator. The original implementation trains the models with dpo and sft.
@@ -21,8 +21,6 @@ Whereas this implementation uses the models as is.
 
 """
 
-from ast import Mult
-import concurrent.futures
 from typing import List
 
 from loguru import logger
@@ -169,6 +167,7 @@ majority_voting_agent = Agent(
     system_prompt=majority_voting_prompt,
 )
 
+
 class MALT:
     """
     MALT (Mult-Agent Learning Task) orchestrates the interaction between multiple agents
@@ -296,29 +295,26 @@ class MALT:
             task=main_agent_output,
             max_workers=3,
         )
-        
+
         self.conversation.add(
             role=self.verifier_agent.agent_name,
             content=verified_outputs,
         )
-        
-        
+
         ######################### MAJORITY VOTING #########################
 
-        
         # Majority Voting on the verified outputs
         majority_voting_verified = majority_voting_agent.run(
             task=any_to_str(verified_outputs),
         )
 
         self.conversation.add(
-            role=self.majority_voting_agent.agent_name,
+            role=majority_voting_agent.agent_name,
             content=majority_voting_verified,
         )
-        
+
         #########################################################
-        
-        
+
         # Refining the majority voting output
         logger.info("Running task with refiner agents")
         for output in verified_outputs:
@@ -351,6 +347,7 @@ class MALT:
             str or list or dict: The output from the conversation based on the specified return format.
         """
         task = task
+
         for i in range(self.max_loops):
             logger.info(f"Starting iteration {i+1}/{self.max_loops}")
             output = self.step(task, img, *args, **kwargs)
@@ -389,18 +386,3 @@ class MALT:
 
     def __repr__(self):
         return self.conversation.get_str()
-
-    def run_concurrently(self, tasks: List[str], *args, **kwargs):
-        """Executes a list of tasks using the main agent and processes the output through verifier and refiner agents.
-
-        Args:
-            tasks (list[str]): The list of tasks to be executed by the main agent.
-        """
-        logger.info("Running batch of tasks concurrently.")
-        logger.info(f"Number of tasks: {len(tasks)}")
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(self.run, task, *args, **kwargs)
-                for task in tasks
-            ]
-            return concurrent.futures.as_completed(futures)

swarms/structs/swarm_router.py

@@ -306,7 +306,7 @@ class SwarmRouter:
                 *args,
                 **kwargs,
             )
-            
+
         elif self.swarm_type == "MALT":
             return MALT(
                 name=self.name,
@@ -453,9 +453,11 @@ class SwarmRouter:
         self.swarm = self._create_swarm(task, *args, **kwargs)
 
         try:
-            logger.info(f"Running task on {self.swarm_type} swarm with task: {task}")
+            logger.info(
+                f"Running task on {self.swarm_type} swarm with task: {task}"
+            )
             result = self.swarm.run(task=task, *args, **kwargs)
-            
+
             logger.info("Swarm completed successfully")
             return result
         except Exception as e:

swarms/utils/history_output_formatter.py

@@ -0,0 +1,14 @@
+from swarms.structs.conversation import Conversation
+
+
+def history_output_formatter(
+    conversation: Conversation, type: str = "list"
+):
+    if type == "list":
+        return conversation.return_messages_as_list()
+    elif type == "dict":
+        return conversation.to_dict()
+    elif type == "string" or type == "str":
+        return conversation.get_str()
+    else:
+        raise ValueError(f"Invalid type: {type}")