Merge branch 'update/docs' of https://github.com/harshalmore31/swarms into update/docs

docs/mkdocs.yml

@@ -342,6 +342,10 @@ nav:
 
         - Communication Structure: "swarms/structs/conversation.md"
 
+    - Protocol:
+      - Overview: "swarms/protocol/overview.md"
+      - SIPs: "swarms/protocol/sip.md"
+    
     - Tools:
       - Overview: "swarms_tools/overview.md"
       - BaseTool Reference: "swarms/tools/base_tool.md"

docs/protocol/bc.md

@@ -0,0 +1 @@
+# Backwards Compatability

docs/protocol/overview.md

@@ -0,0 +1,416 @@
+# Swarms Protocol Overview & Architecture
+
+This document provides a comprehensive overview of the Swarms protocol architecture, illustrating the flow from agent classes to multi-agent structures, and showcasing the main components and folders within the `swarms/` package. The Swarms framework is designed for extensibility, modularity, and production-readiness, enabling the orchestration of intelligent agents, tools, memory, and complex multi-agent systems.
+
+---
+
+## Introduction
+
+Swarms is an enterprise-grade, production-ready multi-agent orchestration framework. It enables developers and organizations to build, deploy, and manage intelligent agents that can reason, collaborate, and solve complex tasks autonomously or in groups. The architecture is inspired by the principles of modularity, composability, and scalability, ensuring that each component can be extended or replaced as needed.
+
+The protocol is structured to support a wide range of use cases, from simple single-agent automations to sophisticated multi-agent workflows involving memory, tool use, and advanced reasoning.
+
+For a high-level introduction and installation instructions, see the [Swarms Docs Home](https://docs.swarms.world/en/latest/).
+
+---
+
+## High-Level Architecture Flow
+
+The Swarms protocol is organized into several key layers, each responsible for a specific aspect of the system. The typical flow is as follows:
+
+1. **Agent Class (`swarms/agents`)**
+    
+    - The core building block of the framework. Agents encapsulate logic, state, and behavior. They can be simple (stateless) or complex 
+    (stateful, with memory and reasoning capabilities).
+    
+    - Agents can be specialized for different tasks (e.g., reasoning agents, tool agents, judge agents, etc.).
+
+    
+    - Example: A `ReasoningAgent` that can analyze data and make decisions, or a `ToolAgent` that wraps external APIs.
+
+    
+    - [Quickstart for Agents](https://docs.swarms.world/en/latest/swarms/agents/)
+
+    
+    - [Agent API Reference](https://docs.swarms.world/en/latest/swarms/structs/agent/)
+
+
+2. **Tools with Memory (`swarms/tools`, `swarms/utils`)**
+    - Tools are modular components that agents use to interact with the outside world, perform computations, or access resources (APIs, 
+    databases, files, etc.).
+
+    - Memory modules and utility functions allow agents to retain context, cache results, and manage state across interactions.
+
+    - Example: A tool for calling an LLM API, a memory cache for conversation history, or a utility for parsing and formatting data.
+
+    - [Tools Overview](https://docs.swarms.world/en/latest/swarms_tools/overview/)
+
+    - [BaseTool Reference](https://docs.swarms.world/en/latest/swarms/tools/base_tool/)
+
+
+3. **Reasoning & Specialized Agents (`swarms/agents`)**
+    - These agents build on the base agent class, adding advanced reasoning, self-consistency, and specialized logic for tasks like 
+    planning, evaluation, or multi-step workflows.
+
+    - Includes agents for self-reflection, iterative improvement, and domain-specific expertise.
+
+    - Example: A `SelfConsistencyAgent` that aggregates multiple reasoning paths, or a `JudgeAgent` that evaluates outputs from other 
+    agents.
+
+    - [Reasoning Agents Overview](https://docs.swarms.world/en/latest/swarms/agents/reasoning_agents_overview/)
+
+    - [Self Consistency Agent](https://docs.swarms.world/en/latest/swarms/agents/consistency_agent/)
+
+    - [Agent Judge](https://docs.swarms.world/en/latest/swarms/agents/agent_judge/)
+
+
+4. **Multi-Agent Structures (`swarms/structs`)**
+    - Agents are composed into higher-order structures for collaboration, voting, parallelism, and workflow orchestration.
+
+    - Includes swarms for majority voting, round-robin execution, hierarchical delegation, and more.
+
+    - Example: A `MajorityVotingSwarm` that aggregates outputs from several agents, or a `HierarchicalSwarm` that delegates tasks to 
+    sub-agents.
+
+    - [Multi-Agent Architectures Overview](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/)
+
+    - [MajorityVotingSwarm](https://docs.swarms.world/en/latest/swarms/structs/majorityvoting/)
+
+    - [HierarchicalSwarm](https://docs.swarms.world/en/latest/swarms/structs/hierarchical_swarm/)
+
+    - [Sequential Workflow](https://docs.swarms.world/en/latest/swarms/structs/sequential_workflow/)
+
+    - [Concurrent Workflow](https://docs.swarms.world/en/latest/swarms/structs/concurrentworkflow/)
+
+
+5. **Supporting Components**
+
+    - **Communication (`swarms/communication`)**: Provides wrappers for inter-agent communication, database access, message passing, and 
+    integration with external systems (e.g., Redis, DuckDB, Pulsar). See [Communication Structure](https://docs.swarms.world/en/latest/swarms/structs/conversation/)
+    
+    - **Artifacts (`swarms/artifacts`)**: Manages the creation, storage, and retrieval of artifacts (outputs, files, logs) generated by 
+    agents and swarms.
+    
+    - **Prompts (`swarms/prompts`)**: Houses prompt templates, system prompts, and agent-specific prompts for LLM-based agents. See 
+    [Prompts Management](https://docs.swarms.world/en/latest/swarms/prompts/main/)
+    
+    - **Telemetry (`swarms/telemetry`)**: Handles logging, monitoring, and bootup routines for observability and debugging.
+
+    - **Schemas (`swarms/schemas`)**: Defines data schemas for agents, tools, completions, and communication protocols, ensuring type 
+    safety and consistency.
+    
+    - **CLI (`swarms/cli`)**: Provides command-line utilities for agent creation, management, and orchestration. See [CLI Documentation]
+    (https://docs.swarms.world/en/latest/swarms/cli/main/)
+
+---
+
+## Detailed Architecture Diagram
+
+The following Mermaid diagram visualizes the protocol flow and the relationship between the main folders in the `swarms/` package:
+
+```mermaid
+flowchart TD
+    A["Agent Class<br/>(swarms/agents)"] --> B["Tools with Memory<br/>(swarms/tools, swarms/utils)"]
+    B --> C["Reasoning & Specialized Agents<br/>(swarms/agents)"]
+    C --> D["Multi-Agent Structures<br/>(swarms/structs)"]
+    D --> E["Communication, Artifacts, Prompts, Telemetry, Schemas, CLI"]
+    
+    subgraph Folders
+        A1["agents"]
+        A2["tools"]
+        A3["structs"]
+        A4["utils"]
+        A5["telemetry"]
+        A6["schemas"]
+        A7["prompts"]
+        A8["artifacts"]
+        A9["communication"]
+        A10["cli"]
+    end
+    
+    %% Folder showcase
+    subgraph "swarms/"
+        A1
+        A2
+        A3
+        A4
+        A5
+        A6
+        A7
+        A8
+        A9
+        A10
+    end
+    
+    %% Connect folder showcase to main flow
+    A1 -.-> A
+    A2 -.-> B
+    A3 -.-> D
+    A4 -.-> B
+    A5 -.-> E
+    A6 -.-> E
+    A7 -.-> E
+    A8 -.-> E
+    A9 -.-> E
+    A10 -.-> E
+```
+
+---
+
+## Folder-by-Folder Breakdown
+
+### `agents/`
+
+**Purpose:** Defines all agent classes, including base agents, reasoning agents, tool agents, judge agents, and more.
+
+**Highlights:**
+
+- Modular agent design for extensibility.
+
+- Support for YAML-based agent creation and configuration. See [YAML Agent Creation](https://docs.swarms.world/en/latest/swarms/
+agents/create_agents_yaml/)
+
+- Specialized agents for self-consistency, evaluation, and domain-specific tasks.
+
+- **Example:**
+
+- `ReasoningAgent`, `ToolAgent`, `JudgeAgent`, `ConsistencyAgent`, `OpenAIAssistant`, etc.
+
+- [Agents Overview](https://docs.swarms.world/en/latest/swarms/framework/agents_explained/)
+
+
+### `tools/`
+
+**Purpose:** Houses all tool-related logic, including tool registry, function calling, tool schemas, and integration with external 
+APIs.
+
+**Highlights:**
+
+- Tools can be dynamically registered and called by agents.
+
+- Support for OpenAI function calling, Cohere, and custom tool schemas.
+
+- Utilities for parsing, formatting, and executing tool calls.
+
+- **Example:**
+
+- `base_tool.py`, `tool_registry.py`, `mcp_client_call.py`, `func_calling_utils.py`, etc.
+
+- [Tools Reference](https://docs.swarms.world/en/latest/swarms/tools/tools_examples/)
+
+- [What are tools?](https://docs.swarms.world/en/latest/swarms/tools/build_tool/)
+
+
+### `structs/`
+**Purpose:** Implements multi-agent structures, workflows, routers, registries, and orchestration logic.
+
+**Highlights:**
+
+- Swarms for majority voting, round-robin, hierarchical delegation, spreadsheet processing, and more.
+
+- Workflow orchestration (sequential, concurrent, graph-based).
+
+- Utilities for agent matching, rearrangement, and evaluation.
+
+- **Example:**
+
+- `MajorityVotingSwarm`, `HierarchicalSwarm`, `SwarmRouter`, `SequentialWorkflow`, `ConcurrentWorkflow`, etc.
+
+- [Custom Multi Agent Architectures](https://docs.swarms.world/en/latest/swarms/structs/custom_swarm/)
+
+- [SwarmRouter](https://docs.swarms.world/en/latest/swarms/structs/swarm_router/)
+
+- [AgentRearrange](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/)
+
+
+### `utils/`
+
+**Purpose:** Provides utility functions, memory management, caching, wrappers, and helpers used throughout the framework.
+
+**Highlights:**
+
+- Memory and caching for agents and tools. See [Integrating RAG with Agents](https://docs.swarms.world/en/latest/swarms/memory/
+diy_memory/)
+
+- Wrappers for concurrency, logging, and data processing.
+
+- General-purpose utilities for string, file, and data manipulation.
+
+**Example:**
+
+- `agent_cache.py`, `concurrent_wrapper.py`, `file_processing.py`, `formatter.py`, etc.
+
+
+### `telemetry/`
+
+**Purpose:** Handles telemetry, logging, monitoring, and bootup routines for the framework.
+
+**Highlights:**
+
+- Centralized logging and execution tracking.
+
+- Bootup routines for initializing the framework.
+
+- Utilities for monitoring agent and swarm performance.
+
+- **Example:**
+
+- `bootup.py`, `log_executions.py`, `main.py`.
+
+
+### `schemas/`
+
+**Purpose:** Defines data schemas for agents, tools, completions, and communication protocols.
+
+**Highlights:**
+
+- Ensures type safety and consistency across the framework.
+
+- Pydantic-based schemas for validation and serialization.
+
+- Schemas for agent classes, tool calls, completions, and more.
+
+**Example:**
+
+- `agent_class_schema.py`, `tool_schema_base_model.py`, `agent_completion_response.py`, etc.
+
+
+### `prompts/`
+
+**Purpose:** Contains prompt templates, system prompts, and agent-specific prompts for LLM-based agents.
+
+**Highlights:**
+
+- Modular prompt design for easy customization.
+
+- Support for multi-modal, collaborative, and domain-specific prompts.
+
+- Templates for system, task, and conversational prompts.
+
+**Example:**
+
+- `prompt.py`, `reasoning_prompt.py`, `multi_agent_collab_prompt.py`, etc.
+
+- [Prompts Management](https://docs.swarms.world/en/latest/swarms/prompts/main/)
+
+
+### `artifacts/`
+
+**Purpose:** Manages the creation, storage, and retrieval of artifacts (outputs, files, logs) generated by agents and swarms.
+
+**Highlights:**
+
+- Artifact management for reproducibility and traceability.
+- Support for various output types and formats.
+
+**Example:**
+
+- `main_artifact.py`.
+
+
+### `communication/`
+
+**Purpose:** Provides wrappers for inter-agent communication, database access, message passing, and integration with external systems.
+
+**Highlights:**
+
+- Support for Redis, DuckDB, Pulsar, Supabase, and more.
+- Abstractions for message passing and data exchange between agents.
+
+**Example:**
+
+- `redis_wrap.py`, `duckdb_wrap.py`, `base_communication.py`, etc.
+
+- [Communication Structure](https://docs.swarms.world/en/latest/swarms/structs/conversation/)
+
+
+### `cli/`
+
+**Purpose:** Command-line utilities for agent creation, management, and orchestration.
+
+**Highlights:**
+
+- Scripts for onboarding, agent creation, and management.
+
+- CLI entry points for interacting with the framework.
+
+**Example:**
+
+- `main.py`, `create_agent.py`, `onboarding_process.py`.
+
+- [CLI Documentation](https://docs.swarms.world/en/latest/swarms/cli/main/)
+
+
+---
+
+## How the System Works Together
+
+The Swarms protocol is designed for composability. Agents can be created and configured independently, then composed into larger structures (swarms) for collaborative or competitive workflows. Tools and memory modules are injected into agents as needed, enabling them to perform complex tasks and retain context. Multi-agent structures orchestrate the flow of information and decision-making, while supporting components (communication, telemetry, artifacts, etc.) ensure robustness, observability, and extensibility.
+
+For example, a typical workflow might involve:
+
+- Creating a set of specialized agents (e.g., data analyst, summarizer, judge).
+
+- Registering tools (e.g., LLM API, database access, web search) and memory modules.
+
+- Composing agents into a `MajorityVotingSwarm` for collaborative decision-making.
+
+- Using communication wrappers to exchange data between agents and external systems.
+
+- Logging all actions and outputs for traceability and debugging.
+
+
+For more advanced examples, see the [Examples Overview](https://docs.swarms.world/en/latest/examples/index/).
+
+---
+
+## Swarms Framework Philosophy
+
+Swarms is built on the following principles:
+
+- **Modularity:** Every component (agent, tool, prompt, schema) is a module that can be extended or replaced.
+
+- **Composability:** Agents and tools can be composed into larger structures for complex workflows.
+
+- **Observability:** Telemetry and artifact management ensure that all actions are traceable and debuggable.
+
+- **Extensibility:** New agents, tools, and workflows can be added with minimal friction.
+
+- **Production-Readiness:** The framework is designed for reliability, scalability, and real-world deployment.
+
+
+For more on the philosophy and architecture, see [Development Philosophy & Principles](https://docs.swarms.world/en/latest/swarms/concept/philosophy/) and [Understanding Swarms Architecture](https://docs.swarms.world/en/latest/swarms/concept/framework_architecture/).
+
+---
+
+## Further Reading & References
+
+- [Swarms Docs Home](https://docs.swarms.world/en/latest/)
+
+- [Quickstart for Agents](https://docs.swarms.world/en/latest/swarms/agents/)
+
+- [Agent API Reference](https://docs.swarms.world/en/latest/swarms/structs/agent/)
+
+- [Tools Overview](https://docs.swarms.world/en/latest/swarms_tools/overview/)
+
+- [BaseTool Reference](https://docs.swarms.world/en/latest/swarms/tools/base_tool/)
+
+- [Reasoning Agents Overview](https://docs.swarms.world/en/latest/swarms/agents/reasoning_agents_overview/)
+
+- [Multi-Agent Architectures Overview](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/)
+
+- [Examples Overview](https://docs.swarms.world/en/latest/examples/index/)
+
+- [CLI Documentation](https://docs.swarms.world/en/latest/swarms/cli/main/)
+
+- [Prompts Management](https://docs.swarms.world/en/latest/swarms/prompts/main/)
+
+- [Development Philosophy & Principles](https://docs.swarms.world/en/latest/swarms/concept/philosophy/)
+
+- [Understanding Swarms Architecture](https://docs.swarms.world/en/latest/swarms/concept/framework_architecture/)
+
+
+# Conclusion
+
+The Swarms protocol provides a robust foundation for building intelligent, collaborative, and autonomous systems. By organizing the codebase into clear, modular folders and defining a logical flow from agents to multi-agent structures, Swarms enables rapid development and deployment of advanced AI solutions. Whether you are building a simple automation or a complex multi-agent application, the Swarms architecture provides the tools and abstractions you need to succeed.
+

docs/protocol/sip.md

@@ -0,0 +1,159 @@
+# Swarms Improvement Proposal (SIP) Guidelines
+
+A simplified process for proposing new functionality and enhancements to the Swarms framework.
+
+## What is a SIP?
+
+A **Swarms Improvement Proposal (SIP)** is a design document that describes a new feature, enhancement, or change to the Swarms framework. SIPs serve as the primary mechanism for proposing significant changes, collecting community feedback, and documenting design decisions.
+
+The SIP author is responsible for building consensus within the community and documenting the proposal clearly and concisely.
+
+## When to Submit a SIP
+
+Consider submitting a SIP for:
+
+- **New Agent Types or Behaviors**: Adding new agent architectures, swarm patterns, or coordination mechanisms
+- **Core Framework Changes**: Modifications to the Swarms API, core classes, or fundamental behaviors
+- **New Integrations**: Adding support for new LLM providers, tools, or external services
+- **Breaking Changes**: Any change that affects backward compatibility
+- **Complex Features**: Multi-component features that require community discussion and design review
+
+For simple bug fixes, minor enhancements, or straightforward additions, use regular GitHub issues and pull requests instead.
+
+## SIP Types
+
+**Standard SIP**: Describes a new feature or change to the Swarms framework
+**Process SIP**: Describes changes to development processes, governance, or community guidelines
+**Informational SIP**: Provides information or guidelines to the community without proposing changes
+
+## Submitting a SIP
+
+1. **Discuss First**: Post your idea in [GitHub Discussions](https://github.com/kyegomez/swarms/discussions) to gauge community interest
+2. **Create Issue**: Submit your SIP as a GitHub Issue with the `SIP` and `proposal` labels
+3. **Follow Format**: Use the SIP template format below
+4. **Engage Community**: Respond to feedback and iterate on your proposal
+
+## SIP Format
+
+### Required Sections
+
+#### **SIP Header**
+```
+Title: [Descriptive title]
+Author: [Your name and contact]
+Type: [Standard/Process/Informational]
+Status: Proposal
+Created: [Date]
+```
+
+#### **Abstract** (200 words max)
+A brief summary of what you're proposing and why.
+
+#### **Motivation**
+- What problem does this solve?
+- Why can't the current framework handle this?
+- What are the benefits to the Swarms ecosystem?
+
+#### **Specification**
+- Detailed technical description
+- API changes or new interfaces
+- Code examples showing usage
+- Integration points with existing framework
+
+#### **Implementation Plan**
+- High-level implementation approach
+- Breaking changes (if any)
+- Migration path for existing users
+- Testing strategy
+
+#### **Alternatives Considered**
+- Other approaches you evaluated
+- Why you chose this solution
+- Trade-offs and limitations
+
+### Optional Sections
+
+#### **Reference Implementation**
+Link to prototype code or proof-of-concept (can be added later)
+
+#### **Security Considerations**
+Any security implications or requirements
+
+## SIP Workflow
+
+```
+Proposal → Draft → Review → Accepted/Rejected → Final
+```
+
+1. **Proposal**: Initial submission as GitHub Issue
+2. **Draft**: Maintainer assigns SIP number and `draft` label
+3. **Review**: Community and maintainer review period
+4. **Decision**: Accepted, rejected, or needs revision
+5. **Final**: Implementation completed and merged
+
+## SIP Status
+
+- **Proposal**: Newly submitted, awaiting initial review
+- **Draft**: Under active discussion and refinement
+- **Review**: Formal review by maintainers
+- **Accepted**: Approved for implementation
+- **Rejected**: Not accepted (with reasons)
+- **Final**: Implementation completed and merged
+- **Withdrawn**: Author withdrew the proposal
+
+## Review Process
+
+- SIPs are reviewed during regular maintainer meetings
+- Community feedback is collected via GitHub comments
+- Acceptance requires:
+  - Clear benefit to the Swarms ecosystem
+  - Technical feasibility
+  - Community support
+  - Working prototype (for complex features)
+
+## Getting Help
+
+- **Discussions**: Use [GitHub Discussions](https://github.com/kyegomez/swarms/discussions) for questions
+- **Documentation**: Check [docs.swarms.world](https://docs.swarms.world) for framework details
+- **Examples**: Look at existing SIPs for reference
+
+## SIP Template
+
+When creating your SIP, copy this template:
+
+```markdown
+# SIP-XXX: [Title]
+
+**Author**: [Your name] <[email]>
+**Type**: Standard
+**Status**: Proposal
+**Created**: [Date]
+
+## Abstract
+
+[Brief 200-word summary]
+
+## Motivation
+
+[Why is this needed? What problem does it solve?]
+
+## Specification
+
+[Detailed technical description with code examples]
+
+## Implementation Plan
+
+[How will this be built? Any breaking changes?]
+
+## Alternatives Considered
+
+[Other approaches and why you chose this one]
+
+## Reference Implementation
+
+[Link to prototype code if available]
+```
+
+---
+
+**Note**: This process is designed to be lightweight while ensuring important changes get proper community review. For questions about whether your idea needs a SIP, start a discussion in the GitHub Discussions forum.

examples/mcp/client.py

@@ -0,0 +1,26 @@
+from swarms.tools.mcp_client_call import (
+    execute_tool_call_simple,
+    get_mcp_tools_sync,
+)
+
+
+async def main():
+    # Prepare the tool call in OpenAI-compatible format
+    response = {
+        "function": {"name": "greet", "arguments": {"name": "Alice"}}
+    }
+    result = await execute_tool_call_simple(
+        server_path="http://localhost:8000/mcp",
+        response=response,
+        # transport="streamable_http",
+    )
+    print("Tool call result:", result)
+    return result
+
+
+if __name__ == "__main__":
+    print(get_mcp_tools_sync(server_path="http://localhost:8000/mcp"))
+
+    import asyncio
+
+    asyncio.run(main())

examples/mcp/test.py

@@ -0,0 +1,28 @@
+"""
+Run from the repository root:
+    uv run examples/snippets/servers/streamable_config.py
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+# Stateful server (maintains session state)
+mcp = FastMCP("StatefulServer", json_response=True)
+
+# Other configuration options:
+# Stateless server (no session persistence)
+# mcp = FastMCP("StatelessServer", stateless_http=True)
+
+# Stateless server (no session persistence, no sse stream with supported client)
+# mcp = FastMCP("StatelessServer", stateless_http=True, json_response=True)
+
+
+# Add a simple tool to demonstrate the server
+@mcp.tool()
+def greet(name: str = "World") -> str:
+    """Greet someone by name."""
+    return f"Hello, {name}!"
+
+
+# Run server with streamable_http transport
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http")

pyproject.toml

@@ -78,6 +78,7 @@ litellm = "*"
 torch = "*"
 httpx = "*"
 mcp = "*"
+openai = "*"
 aiohttp = "*"
 
 [tool.poetry.scripts]

requirements.txt

@@ -26,3 +26,4 @@ httpx
 aiohttp
 mcp
 numpy
+openai

swarms/schemas/mcp_schemas.py

@@ -8,7 +8,7 @@ class MCPConnection(BaseModel):
         description="The type of connection, defaults to 'mcp'",
     )
     url: Optional[str] = Field(
-        default="localhost:8000/sse",
+        default="http://localhost:8000/mcp",
         description="The URL endpoint for the MCP server",
     )
     tool_configurations: Optional[Dict[Any, Any]] = Field(
@@ -20,18 +20,19 @@ class MCPConnection(BaseModel):
         description="Authentication token for accessing the MCP server",
     )
     transport: Optional[str] = Field(
-        default="sse",
+        default="streamable_http",
         description="The transport protocol to use for the MCP server",
     )
     headers: Optional[Dict[str, str]] = Field(
         default=None, description="Headers to send to the MCP server"
     )
     timeout: Optional[int] = Field(
-        default=5, description="Timeout for the MCP server"
+        default=10, description="Timeout for the MCP server"
     )
 
     class Config:
         arbitrary_types_allowed = True
+        extra = "allow"
 
 
 class MultipleMCPConnections(BaseModel):

swarms/structs/interactive_groupchat.py

@@ -951,6 +951,30 @@ Remember: You are part of a team. Your response should reflect that you've read,
         for agent_name in speaking_order:
             self._get_agent_response(agent_name, img, imgs)
 
+    def _process_random_speaker(
+        self,
+        mentioned_agents: List[str],
+        img: Optional[str],
+        imgs: Optional[List[str]],
+    ) -> None:
+        """
+        Process responses using the random speaker function.
+        This function randomly selects a single agent from the mentioned agents
+        to respond to the user query.
+        """
+        # Filter out invalid agents
+        valid_agents = [name for name in mentioned_agents if name in self.agent_map]
+        
+        if not valid_agents:
+            raise AgentNotFoundError("No valid agents found in the conversation")
+        
+        # Randomly select exactly one agent to respond
+        random_agent = random.choice(valid_agents)
+        logger.info(f"Random speaker selected: {random_agent}")
+        
+        # Get response from the randomly selected agent
+        self._get_agent_response(random_agent, img, imgs)
+
     def run(
         self,
         task: str,
@@ -987,6 +1011,11 @@ Remember: You are part of a team. Your response should reflect that you've read,
                 self._process_dynamic_speakers(
                     mentioned_agents, img, imgs
                 )
+            elif self.speaker_function == random_speaker:
+                # Use the specialized function for random_speaker
+                self._process_random_speaker(
+                    mentioned_agents, img, imgs
+                )    
             else:
                 self._process_static_speakers(
                     mentioned_agents, img, imgs

swarms/utils/function_caller_model.py

@@ -1,23 +1,11 @@
 import os
-import subprocess
 from concurrent.futures import ThreadPoolExecutor
 from typing import List
 
-from loguru import logger
 from pydantic import BaseModel
 
 
-try:
+from openai import OpenAI
-    from openai import OpenAI
-except ImportError:
-    logger.error(
-        "OpenAI library not found. Please install the OpenAI library by running 'pip install openai'"
-    )
-    import sys
-
-    subprocess.run([sys.executable, "-m", "pip", "install", "openai"])
-    from openai import OpenAI
-
 
 SUPPORTED_MODELS = [
     "o3-mini-2025-1-31",