ai-agentswarm 0.1.1__tar.gz

ai_agentswarm-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Luca Roverelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_agentswarm-0.1.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

ai_agentswarm-0.1.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: ai-agentswarm
+Version: 0.1.1
+Summary: A recursive, functional, and state-isolated Multi-Agent Framework.
+Author-email: Lucas Roverelli <lucas.roverelli@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Luca Roverelli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/ai-agentswarm/agentswarm
+Project-URL: Bug Tracker, https://github.com/ai-agentswarm/agentswarm/issues
+Project-URL: Documentation, https://github.com/ai-agentswarm/agentswarm#readme
+Keywords: ai,agents,llm,framework,recursive,react
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: google-genai>=1.50.1
+Requires-Dist: mcp
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: examples
+Requires-Dist: httpx; extra == "examples"
+Requires-Dist: python-dotenv; extra == "examples"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Dynamic: license-file
+
+# 🐝 AgentSwarm
+
+**A Recursive, Functional, and Type-Safe Framework for Autonomous AI Agents.**
+
+![Logo](docs/media/logo_bg.png)
+
+**AgentSwarm** is a next-generation agentic orchestration framework designed to solve the critical issues of **Context Pollution** and **Complex Orchestration** in multi-agent systems.
+
+Unlike chat-based frameworks (like AutoGen) or static graph frameworks (like LangGraph), AgentSwarm treats agents as **Strongly Typed Asynchronous Functions** that operate in isolated environments ("Tabula Rasa"), natively supporting recursion and Map-Reduce patterns.
+
+## 🚀 Why AgentSwarm?
+
+Current architectures suffer from two main problems:
+1.  **Context Pollution:** Sub-agents inherit the parent's entire chat history, wasting tokens, increasing latency, and confusing the model.
+2.  **Boilerplate Hell:** Defining dynamic recursive graphs requires complex configuration and rigid state definitions.
+
+**AgentSwarm solves these problems:**
+
+* **🧠 Tabula Rasa Execution:** Every invoked agent starts with a *clean* context. The sub-agent receives only the specific input required, executes the task, and returns the output. No noise, no context window overflow.
+* **📦 Native Blackboard Pattern:** Agents don't pass massive raw text strings back and forth. They use a shared **Key-Value Store** to manipulate, transform, and merge data, exchanging only references (Keys).
+* **🛡️ Type-Safe by Design:** Built on Pydantic and Python Generics. Agent inputs and outputs are validated at runtime, and JSON schemas for the LLM are generated automatically from type hints.
+* **⚡ Implicit Parallelism:** The `ReActAgent` engine automatically handles parallel tool execution (Map) and result aggregation (Reduce) without complex graph definitions.
+
+## 🛠️ Architecture
+
+AgentSwarm is built on three fundamental concepts:
+
+### 1. Agent-as-a-Function
+Every agent is a class inheriting from `BaseAgent[Input, Output]`. There are no "nodes" or "edges" to manually define. Orchestration emerges naturally from the functional calls between agents.
+Moreover, agents are **strongly typed** and **asynchronous** by design, making them easy to compose and debug. When errors occur, they are propagated as standard exceptions, that can be managed by agents at different levels.
+
+### 2. The "Store" (Shared Memory)
+Instead of overloading the chat context, agents use the `Store` to manage information. We provide a set of agents to ease the management of the store:
+* **GatheringAgent:** Retrieves data from the store for display or processing.
+* **TransformerAgent:** Transforms data in the store (e.g., summarize, filter) using natural language commands and returns a new Key, keeping the context light.
+* **MergeAgent:** Combines multiple data keys into a single entity.
+
+### 3. Recursive Map-Reduce
+The Map-Reduce pattern is a powerful way to decompose complex tasks into smaller, parallelizable subtasks. It is used since decades in parallel computing. With AgentSwarm, we borrow this pattern to ease the orchestration of complex tasks, preventing context pullution or exosting, prefering to use the store as a shared memory.
+A `MapReduceAgent` can decompose complex tasks, dynamically instantiate clones of itself or other agents, and execute work in parallel, avoiding deadlocks via instance isolation.
+
+### 4. Interoperability & Hybrid Execution
+AgentSwarm is designed to be an open ecosystem, not a walled garden.
+* **Protocol Agnostic:** It (will) supports the **Model Context Protocol (MCP)** and **Agent-to-Agent (A2A)** standards, allowing your agents to interact seamlessly with external tools and third-party agent networks. You can also easily wrap existing **LangChain** tools and run them within the Swarm.
+* **Hybrid Runtime:** Each agent can be executed locally, or remotly, exploiting **AWS** or **Google Cloud** services. Also the Store can be a remote key-value store, like Redis.
+

ai_agentswarm-0.1.1/README.md

@@ -0,0 +1,46 @@
+# 🐝 AgentSwarm
+
+**A Recursive, Functional, and Type-Safe Framework for Autonomous AI Agents.**
+
+![Logo](docs/media/logo_bg.png)
+
+**AgentSwarm** is a next-generation agentic orchestration framework designed to solve the critical issues of **Context Pollution** and **Complex Orchestration** in multi-agent systems.
+
+Unlike chat-based frameworks (like AutoGen) or static graph frameworks (like LangGraph), AgentSwarm treats agents as **Strongly Typed Asynchronous Functions** that operate in isolated environments ("Tabula Rasa"), natively supporting recursion and Map-Reduce patterns.
+
+## 🚀 Why AgentSwarm?
+
+Current architectures suffer from two main problems:
+1.  **Context Pollution:** Sub-agents inherit the parent's entire chat history, wasting tokens, increasing latency, and confusing the model.
+2.  **Boilerplate Hell:** Defining dynamic recursive graphs requires complex configuration and rigid state definitions.
+
+**AgentSwarm solves these problems:**
+
+* **🧠 Tabula Rasa Execution:** Every invoked agent starts with a *clean* context. The sub-agent receives only the specific input required, executes the task, and returns the output. No noise, no context window overflow.
+* **📦 Native Blackboard Pattern:** Agents don't pass massive raw text strings back and forth. They use a shared **Key-Value Store** to manipulate, transform, and merge data, exchanging only references (Keys).
+* **🛡️ Type-Safe by Design:** Built on Pydantic and Python Generics. Agent inputs and outputs are validated at runtime, and JSON schemas for the LLM are generated automatically from type hints.
+* **⚡ Implicit Parallelism:** The `ReActAgent` engine automatically handles parallel tool execution (Map) and result aggregation (Reduce) without complex graph definitions.
+
+## 🛠️ Architecture
+
+AgentSwarm is built on three fundamental concepts:
+
+### 1. Agent-as-a-Function
+Every agent is a class inheriting from `BaseAgent[Input, Output]`. There are no "nodes" or "edges" to manually define. Orchestration emerges naturally from the functional calls between agents.
+Moreover, agents are **strongly typed** and **asynchronous** by design, making them easy to compose and debug. When errors occur, they are propagated as standard exceptions, that can be managed by agents at different levels.
+
+### 2. The "Store" (Shared Memory)
+Instead of overloading the chat context, agents use the `Store` to manage information. We provide a set of agents to ease the management of the store:
+* **GatheringAgent:** Retrieves data from the store for display or processing.
+* **TransformerAgent:** Transforms data in the store (e.g., summarize, filter) using natural language commands and returns a new Key, keeping the context light.
+* **MergeAgent:** Combines multiple data keys into a single entity.
+
+### 3. Recursive Map-Reduce
+The Map-Reduce pattern is a powerful way to decompose complex tasks into smaller, parallelizable subtasks. It is used since decades in parallel computing. With AgentSwarm, we borrow this pattern to ease the orchestration of complex tasks, preventing context pullution or exosting, prefering to use the store as a shared memory.
+A `MapReduceAgent` can decompose complex tasks, dynamically instantiate clones of itself or other agents, and execute work in parallel, avoiding deadlocks via instance isolation.
+
+### 4. Interoperability & Hybrid Execution
+AgentSwarm is designed to be an open ecosystem, not a walled garden.
+* **Protocol Agnostic:** It (will) supports the **Model Context Protocol (MCP)** and **Agent-to-Agent (A2A)** standards, allowing your agents to interact seamlessly with external tools and third-party agent networks. You can also easily wrap existing **LangChain** tools and run them within the Swarm.
+* **Hybrid Runtime:** Each agent can be executed locally, or remotly, exploiting **AWS** or **Google Cloud** services. Also the Store can be a remote key-value store, like Redis.
+

ai_agentswarm-0.1.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai-agentswarm"
+version = "0.1.1"
+description = "A recursive, functional, and state-isolated Multi-Agent Framework."
+readme = "README.md"
+authors = [
+  { name = "Lucas Roverelli", email = "lucas.roverelli@gmail.com" },
+]
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "pydantic>=2.12.4",
+    "google-genai>=1.50.1",
+    "mcp"
+]
+keywords = ["ai", "agents", "llm", "framework", "recursive", "react"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "twine",       
+    "build",       
+    "black",
+    "isort"
+]
+examples = [
+    "httpx",
+    "python-dotenv"
+]
+docs = [
+    "mkdocs",
+    "mkdocs-material",
+    "mkdocstrings[python]"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ai-agentswarm/agentswarm"
+"Bug Tracker" = "https://github.com/ai-agentswarm/agentswarm/issues"
+"Documentation" = "https://github.com/ai-agentswarm/agentswarm#readme"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ai_agentswarm-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai_agentswarm-0.1.1/src/agentswarm/agents/__init__.py

@@ -0,0 +1,26 @@
+from .react_agent import ReActAgent
+from .map_reduce_agent import MapReduceAgent, MapReduceInput
+from .gathering_agent import GatheringAgent, GatheringAgentInput
+from .merge_agent import MergeAgent, MergeAgentInput
+from .transformer_agent import TransformerAgent, TransformerAgentInput
+from .thinking_agent import ThinkingAgent, ThinkingInput
+from .base_agent import BaseAgent
+
+from .mcp_agent import MCPBaseAgent, MCPToolAgent
+
+__all__ = [
+    "ReActAgent",
+    "MapReduceAgent",
+    "MapReduceInput",
+    "GatheringAgent",
+    "GatheringAgentInput",
+    "MergeAgent",
+    "MergeAgentInput",
+    "TransformerAgent",
+    "TransformerAgentInput",
+    "ThinkingAgent",
+    "ThinkingInput",
+    "BaseAgent",
+    "MCPBaseAgent",
+    "MCPToolAgent",
+]

ai_agentswarm-0.1.1/src/agentswarm/agents/base_agent.py

@@ -0,0 +1,53 @@
+from abc import abstractmethod
+from typing import TypeVar, Generic, get_args
+
+from pydantic import BaseModel
+from ..datamodels import Context
+
+
+InputType = TypeVar('InputType', bound=BaseModel)
+OutputType = TypeVar('OutputType', bound=BaseModel)
+
+
+class BaseAgent(Generic[InputType, OutputType]):
+
+    @abstractmethod
+    def id(self) -> str:
+        pass
+
+    @abstractmethod
+    def description(self, user_id: str) -> str:
+        pass
+
+    @abstractmethod
+    async def execute(self, user_id: str, context: Context, input: InputType = None) -> OutputType:
+        pass
+
+    def _get_generic_type(self, index: int):
+        """
+        Obtains the concrete type of the generic at the specified index (0 for InputType, 1 for OutputType).
+        Works by inspecting __orig_bases__ of the class at runtime.
+        """
+        for base in getattr(self.__class__, "__orig_bases__", []):
+            origin = getattr(base, "__origin__", None)
+            if origin is BaseAgent or issubclass(origin, BaseAgent):
+                args = get_args(base)
+                if args and len(args) > index:
+                    return args[index]
+        return None
+
+    def input_parameters(self) -> dict:
+        input_type = self._get_generic_type(0)
+        if input_type and hasattr(input_type, 'model_json_schema'):
+            schema = input_type.model_json_schema()
+            schema.pop('title', None)
+            return schema
+        return {}
+    
+    def output_parameters(self) -> dict:
+        output_type = self._get_generic_type(1)
+        if output_type and hasattr(output_type, 'model_json_schema'):
+            schema = output_type.model_json_schema()
+            schema.pop('title', None)
+            return schema
+        return {}

ai_agentswarm-0.1.1/src/agentswarm/agents/gathering_agent.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from .base_agent import BaseAgent
+from ..datamodels import Context
+
+class GatheringAgentInput(BaseModel):
+    key: str = Field(description="The key of the information to gather")
+
+class GatheringAgent(BaseAgent[GatheringAgentInput, str]):
+    def id(self) -> str:
+        return "gathering-agent"
+
+    def description(self, user_id: str) -> str:
+        return """
+I'm able to gather an information from the store and add to the current context. 
+USE THIS AGENT ONLY WHEN YOU NEED TO DISPLAY THE INFORMATION TO THE USER.
+Whenever possible, if you need to filter or process the data, use the "transformer-agent".
+        """
+
+    async def execute(self, user_id: str, context: Context, input: GatheringAgentInput) -> str:
+        if not context.store.has(input.key):
+            raise Exception(f"Information from the store with key {input.key} not found")
+        value = context.store.get(input.key)
+        return value
+
+    

ai_agentswarm-0.1.1/src/agentswarm/agents/map_reduce_agent.py

@@ -0,0 +1,60 @@
+import os
+from typing import List
+
+from pydantic import BaseModel, Field
+from ..llms import LLM, GeminiLLM
+from .base_agent import BaseAgent
+from ..datamodels import Context, Message, KeyStoreResponse
+from .react_agent import ReActAgent
+
+class MapReduceInput(BaseModel):
+    task: str = Field(description="The task to solve, as a string")
+
+class MapReduceAgent(ReActAgent[MapReduceInput, KeyStoreResponse]):
+    def __init__(self, max_iterations: int = 100, agents: List[BaseAgent] = []):
+        super().__init__(max_iterations)
+        self.agents = agents
+
+    def get_llm(self, user_id: str) -> LLM:
+        # TODO: Better LLM consiguration
+        return GeminiLLM(api_key=os.getenv("GEMINI_API_KEY"))
+
+    def id(self) -> str:
+        return "map-reduce"
+    
+    def description(self, user_id: str) -> str:
+        return """USE THIS AGENT FOR:
+        1. COMPLEX CONTENT GENERATION: Creating multi-part artifacts like software libraries, full books, or extensive reports where each chapter/module needs to be generated in parallel.
+        2. RECURSIVE TASKS: Exploration of hierarchical structures (directories, org charts) or recursive problem solving.
+        3. LARGE DATASETS: Processing data that exceeds context limits by splitting (Map) and summarizing (Reduce).
+        4. PARALLEL EXECUTION: Any task requiring massive parallel execution of sub-tasks.
+        
+        DO NOT USE FOR: Simple, linear tasks or single-file creation that fit in a single context window.
+        """
+
+    def prompt(self, user_id: str) -> str:
+        return """You are a recursive Map-Reduce agent. Your GOAL is to solve the given 'task' completely and return the FINAL RESULT.
+        
+        ALGORITHM:
+        1. ANALYZE: Understand the task (e.g., analyze a folder).
+        2. MAP: Break it down into sub-tasks (e.g., read files in current dir, recursively call 'map-reduce' for sub-directories).
+        3. EXECUTE: Run these sub-tasks using the available tools. Parallelize where possible.
+        4. REDUCE: Collect ALL results from the sub-tasks.
+        5. SYNTHESIZE: Combine them into a single, comprehensive final report.
+        
+        CRITICAL RULES:
+        - ANTI-RECURSION: If your assigned task is T, DO NOT call 'map-reduce' with task T again. You must BREAK DOWN task T into smaller sub-tasks (t1, t2...) and delegate THOSE.
+        - You are the one responsible for executing the atomic actions for T (e.g., gathering data, listing items) before delegating sub-parts.
+        - Do NOT return "I am working on it". You must work on it UNTIL IT IS DONE.
+        - Do NOT return partial results unless you have hit a hard limit.
+        - Your final 'assistant' message MUST contain the complete answer/report.
+        """
+
+    def available_agents(self, user_id: str) -> List[BaseAgent]:
+        # IMPORTANT: Return a NEW instance of MapReduceAgent instead of self.
+        return [MapReduceAgent(max_iterations=self.max_iterations, agents=self.agents)] + self.agents
+
+    def generate_messages_context(self, user_id: str, context: Context, input: MapReduceInput = None) -> List[Message]:
+        msgs = super().generate_messages_context(user_id, context, input)
+        msgs.append(Message(type="user", content=f"CURRENT TASK: {input.task}\n\nWARNING: Do not call 'map-reduce' with this exact same task '{input.task}' again, as it would cause an infinite loop. decompose it into smaller sub-tasks."))
+        return msgs

ai_agentswarm-0.1.1/src/agentswarm/agents/mcp_agent.py

@@ -0,0 +1,99 @@
+import asyncio
+from typing import List, Optional, Any, Dict
+from abc import abstractmethod
+from contextlib import asynccontextmanager
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.types import Tool 
+
+from .base_agent import BaseAgent
+from ..datamodels import Context
+
+class MCPToolAgent(BaseAgent[dict, Any]):
+    """
+    An agent that wraps a specific tool from an MCP server.
+    """
+    def __init__(self, session: ClientSession, tool: Tool):
+        self._session = session
+        self._tool = tool
+
+    def id(self) -> str:
+        return self._tool.name
+
+    def description(self, user_id: str) -> str:
+        return self._tool.description or f"Tool {self._tool.name} from MCP server"
+
+    def input_parameters(self) -> dict:
+        # MCP tools define inputSchema in a way compatible with JSON Schema
+        schema = self._tool.inputSchema
+        if schema:
+             # Ensure title is removed if present as per convention in other agents, though optional
+            schema.pop('title', None)
+            return schema
+        return {}
+
+    def output_parameters(self) -> dict:
+        # MCP tools return generic content lists (text, images, etc.)
+        # We don't have a strict schema for the output content structure here yet
+        return {"type": "object", "description": "The result of the tool execution"}
+
+    async def execute(self, user_id: str, context: Context, input: dict = None) -> Any:
+        if input is None:
+            input = {}
+        
+        # Call the tool on the MCP server
+        result = await self._session.call_tool(self._tool.name, arguments=input)
+        
+        # Process result.content which is a list of TextContent | ImageContent | EmbeddedResource
+        # For simplicity, we return the raw list or a simplified text representation
+        # depending on what the framework expects. BaseAgent expects output_type.
+        # Since we defined OutputType as Any, we return the result object or content.
+        return result.content
+
+class MCPBaseAgent:
+    """
+    A base class for connecting to an MCP server and discovering tools.
+    This acts as a factory/manager for MCPToolAgents.
+    """
+    
+    def __init__(self):
+        self._session: Optional[ClientSession] = None
+        self._exit_stack = None
+
+    @abstractmethod
+    def get_server_params(self) -> StdioServerParameters:
+        """
+        Define the connection parameters for the MCP server.
+        """
+        pass
+
+    @asynccontextmanager
+    async def connect(self):
+        """
+        Async context manager to establish connection to the MCP server.
+        """
+        server_params = self.get_server_params()
+        
+        # We manually manage the nested context managers to keep the session alive appropriately
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                self._session = session
+                await session.initialize()
+                yield self
+                self._session = None
+
+    async def get_agents(self) -> List[MCPToolAgent]:
+        """
+        Discovers tools on the connected MCP server and returns them as a list of MCPToolAgent.
+        Must be called within the 'connect' context.
+        """
+        if not self._session:
+            raise RuntimeError("MCP session is not active. Use 'async with agent.connect():'")
+        
+        response = await self._session.list_tools()
+        agents = []
+        for tool in response.tools:
+            agents.append(MCPToolAgent(self._session, tool))
+        
+        return agents

ai_agentswarm-0.1.1/src/agentswarm/agents/merge_agent.py

@@ -0,0 +1,25 @@
+from typing import List
+import uuid
+
+from pydantic import BaseModel, Field
+from .base_agent import BaseAgent
+from ..datamodels import Message, Context, KeyStoreResponse
+
+class MergeAgentInput(BaseModel):
+    keys: List[str] = Field(description="The list of keys to merge")
+
+class MergeAgent(BaseAgent[MergeAgentInput, KeyStoreResponse]):
+    def id(self) -> str:
+        return "merge-agent"
+
+    def description(self, user_id: str) -> str:
+        return "I'm able to merge different informations into a single one."
+
+    async def execute(self, user_id: str, context: Context, input: MergeAgentInput) -> KeyStoreResponse:
+        values = [context.store.get(key) for key in input.keys]
+        value = "\n".join(values)
+        key = f"merged_{uuid.uuid4()}"
+        context.store.set(key, value)
+        return KeyStoreResponse(key=key, description=f"Merged information from keys {input.keys}")
+
+