[FEAT][ToolStorage]

docs/mkdocs.yml

@@ -8,8 +8,6 @@ repo_url: https://github.com/kyegomez/swarms
 edit_uri: https://github.com/kyegomez/swarms/tree/main/docs
 copyright: TGSC Corp 2024. All rights reserved.
 
-
-
 plugins:
   # - glightbox
   - search
@@ -161,6 +159,7 @@ nav:
         - GPT4VisionAPI: "swarms/models/gpt4v.md"
     - Agents:
       - Overview: "swarms/structs/index.md"
+      - Conceptual Overview of Agents: "swarms/framework/agents_explained.md"
       - Build Custom Agents: "swarms/structs/diy_your_own_agent.md"
       - Complete Agent API: "swarms/structs/agent.md"
       - Tasks, Agents with runtimes, triggers, task prioritiies, scheduled tasks, and more: "swarms/structs/task.md"
@@ -169,7 +168,7 @@ nav:
         - What are tools?: "swarms/tools/build_tool.md"
         - ToolAgent: "swarms/agents/tool_agent.md"
         # - Tool Decorator: "swarms/tools/decorator.md"
-        - Tool Storage: "swarms/tools/tool_storage.md"
+        - Tool Storage & tool_registry decorator: "swarms/tools/tool_storage.md"
       - RAG or Long Term Memory:
         - Long Term Memory with RAG: "swarms/memory/diy_memory.md"
     - Artifacts:

docs/swarms/framework/agents_explained.md

@@ -0,0 +1,82 @@
+# An Analysis of Agents
+
+In the Swarms framework, agents are designed to perform tasks autonomously by leveraging large language models (LLMs), various tools, and long-term memory systems. This guide provides an extensive conceptual walkthrough of how an agent operates, detailing the sequence of actions it takes to complete a task and how it utilizes its internal components.
+
+#### Agent Components Overview
+- **LLM (Large Language Model)**: The core component responsible for understanding and generating natural language.
+- **Tools**: External functions and services that the agent can call to perform specific tasks, such as querying databases or interacting with APIs.
+- **Long-term Memory**: Systems like ChromaDB or Pinecone that store and retrieve information over extended periods, enabling the agent to remember past interactions and contexts.
+
+#### Agent Workflow
+The workflow of an agent can be divided into several stages: task initiation, initial LLM processing, tool usage, memory interaction, and final LLM processing.
+
+##### Stage 1: Task Initiation
+- **Input**: The task or query that the agent needs to address.
+- **Output**: A structured plan or approach for handling the task.
+
+##### Stage 2: Initial LLM Processing
+- **Input**: The task or query.
+- **Process**: The LLM interprets the task, understanding the context and requirements.
+- **Output**: An initial response or action plan.
+
+##### Stage 3: Tool Usage
+- **Input**: The action plan or specific sub-tasks identified by the LLM.
+- **Process**: The agent calls various tools to gather information, perform calculations, or interact with external systems.
+  - **Function Calling as Tools**: Tools are called as functions with specific inputs and outputs, enabling the agent to perform a wide range of tasks.
+- **Output**: Data or results from the tools.
+
+##### Stage 4: Memory Interaction
+- **Input**: Intermediate results and context from the tools.
+- **Process**: The agent interacts with long-term memory systems to store new information and retrieve relevant past data.
+  - **RAG Systems (ChromaDB, Pinecone)**: These systems are used to enhance the agent’s responses by providing relevant historical data and context.
+- **Output**: Enhanced context and data for final processing.
+
+##### Stage 5: Final LLM Processing
+- **Input**: Comprehensive data and context from the tools and memory systems.
+- **Process**: The LLM generates the final response or completes the task using the enriched data.
+- **Output**: The final output or action taken by the agent.
+
+### Detailed Workflow with Mermaid Diagrams
+
+#### Agent Components and Workflow
+
+```mermaid
+graph TD
+    A[Task Initiation] -->|Receives Task| B[Initial LLM Processing]
+    B -->|Interprets Task| C[Tool Usage]
+    C -->|Calls Tools| D[Function 1]
+    C -->|Calls Tools| E[Function 2]
+    D -->|Returns Data| C
+    E -->|Returns Data| C
+    C -->|Provides Data| F[Memory Interaction]
+    F -->|Stores and Retrieves Data| G[RAG System]
+    G -->|ChromaDB/Pinecone| H[Enhanced Data]
+    F -->|Provides Enhanced Data| I[Final LLM Processing]
+    I -->|Generates Final Response| J[Output]
+```
+
+### Explanation of Each Stage
+
+#### Stage 1: Task Initiation
+- **Task**: The agent receives a task or query from an external source (e.g., a user query, a system trigger).
+- **Objective**: To understand what needs to be done and prepare an initial approach.
+
+#### Stage 2: Initial LLM Processing
+- **Interpretation**: The LLM processes the task to comprehend its context and requirements.
+- **Planning**: The LLM generates an initial plan or identifies the sub-tasks required to complete the task.
+
+#### Stage 3: Tool Usage
+- **Function Calls**: The agent uses predefined functions (tools) to perform specific actions, such as querying a database or making API calls.
+- **Tool Integration**: Each tool is called with specific parameters, and the results are collected for further processing.
+
+#### Stage 4: Memory Interaction
+- **Long-term Memory**: Systems like ChromaDB and Pinecone store and retrieve long-term data, providing the agent with historical context and past interactions.
+- **Retrieval-Augmented Generation (RAG)**: The agent uses RAG systems to enhance the current context with relevant past data, improving the quality and relevance of the final output.
+
+#### Stage 5: Final LLM Processing
+- **Enhanced Processing**: The LLM processes the enriched data and context provided by the tools and memory systems.
+- **Final Output**: The LLM generates a comprehensive response or completes the task using the enhanced information.
+
+### Conclusion
+
+The Swarms framework's agents are powerful units that combine LLMs, tools, and long-term memory systems to perform complex tasks efficiently. By leveraging function calling for tools and RAG systems like ChromaDB and Pinecone, agents can enhance their capabilities and deliver highly relevant and accurate results. This conceptual guide and walkthrough provide a detailed understanding of how agents operate within the Swarms framework, enabling the development of sophisticated and collaborative AI systems.

docs/swarms/framework/concept.md

@@ -0,0 +1,67 @@
+To create a comprehensive overview of the Swarms framework, we can break it down into key concepts such as models, agents, tools, Retrieval-Augmented Generation (RAG) systems, and swarm systems. Below are conceptual explanations of these components along with mermaid diagrams to illustrate their interactions.
+
+### Swarms Framework Overview
+
+#### 1. **Models**
+Models are the core component of the Swarms framework, representing the neural networks and machine learning models used to perform various tasks. These can be Large Language Models (LLMs), vision models, or any other AI models.
+
+#### 2. **Agents**
+Agents are autonomous units that use models to perform specific tasks. In the Swarms framework, agents can leverage tools and interact with RAG systems.
+
+- **LLMs with Tools**: These agents use large language models along with tools like databases, APIs, and external knowledge sources to enhance their capabilities.
+- **RAG Systems**: These systems combine retrieval mechanisms with generative models to produce more accurate and contextually relevant outputs.
+
+#### 3. **Swarm Systems**
+Swarm systems involve multiple agents working collaboratively to achieve complex tasks. These systems coordinate and communicate among agents to ensure efficient and effective task execution.
+
+### Mermaid Diagrams
+
+#### Models
+
+```mermaid
+graph TD
+    A[Model] -->|Uses| B[Data]
+    A -->|Trains| C[Algorithm]
+    A -->|Outputs| D[Predictions]
+```
+
+#### Agents: LLMs with Tools and RAG Systems
+
+```mermaid
+graph TD
+    A[Agent] -->|Uses| B[LLM]
+    A -->|Interacts with| C[Tool]
+    C -->|Provides Data to| B
+    A -->|Queries| D[RAG System]
+    D -->|Retrieves Information from| E[Database]
+    D -->|Generates Responses with| F[Generative Model]
+```
+
+#### Swarm Systems
+
+```mermaid
+graph TD
+    A[Swarm System]
+    A -->|Coordinates| B[Agent 1]
+    A -->|Coordinates| C[Agent 2]
+    A -->|Coordinates| D[Agent 3]
+    B -->|Communicates with| C
+    C -->|Communicates with| D
+    D -->|Communicates with| B
+    B -->|Performs Task| E[Task 1]
+    C -->|Performs Task| F[Task 2]
+    D -->|Performs Task| G[Task 3]
+    E -->|Reports to| A
+    F -->|Reports to| A
+    G -->|Reports to| A
+```
+
+### Conceptualization
+
+1. **Models**: The basic building blocks trained on specific datasets to perform tasks.
+2. **Agents**: Intelligent entities that utilize models and tools to perform actions. LLM agents can use additional tools to enhance their capabilities.
+3. **RAG Systems**: Enhance agents by combining retrieval mechanisms (to fetch relevant information) with generative models (to create contextually relevant responses).
+4. **Swarm Systems**: Complex systems where multiple agents collaborate, communicate, and coordinate to perform complex, multi-step tasks efficiently.
+
+### Summary
+The Swarms framework leverages models, agents, tools, RAG systems, and swarm systems to create a robust, collaborative environment for executing complex AI tasks. By coordinating multiple agents and enhancing their capabilities with tools and retrieval-augmented generation, Swarms can handle sophisticated and multi-faceted applications effectively.

docs/swarms/framework/vision.md

@@ -142,26 +142,14 @@ graph TD
 
 ---
 
-### Detailed Breakdown
-
-#### Multi-Agent Collaboration
+### Conclusion
 
 Swarms excels in enabling seamless communication and coordination between multiple agents, fostering a collaborative environment where agents can work together to solve complex tasks. Our platform supports cross-agent messaging, task coordination, and real-time updates, ensuring that all agents are synchronized and can efficiently contribute to the collective goal.
 
-#### Integration with Multiple Models
-
 Swarms provides robust integration capabilities with a wide array of models, including OpenAI, Anthropic, Gemini, LangChain, AutoGen, and custom models. This ensures that enterprises can leverage the best models available to meet their specific needs, while also allowing for dynamic model orchestration and version control to keep operations up-to-date and effective.
 
-#### Enterprise Automation
-
 Our framework is designed to enhance operational efficiency through automation. By automating workflows, reducing manual work, and increasing productivity, Swarms helps enterprises achieve higher efficiency and operational excellence. Our solutions are built for high uptime, enterprise-grade security, and scalability, ensuring reliable and secure operations.
 
-#### Open Ecosystem
-
 Swarms promotes an open and extensible ecosystem, encouraging community-driven innovation and development. We support open-source contributions, organize hackathons and workshops, and continuously invest in research and development. Our active community fosters collaborative development, shared resources, and a supportive environment for innovation.
 
----
-
-### Conclusion
-
 **Swarms** is dedicated to providing a comprehensive and powerful framework for enterprises seeking to automate operations through multi-agent collaboration and integration with various models. Our commitment to an open ecosystem, enterprise-grade automation solutions, and seamless multi-agent collaboration ensures that Swarms remains the leading choice for enterprises aiming to achieve operational excellence through intelligent automation.