ai-mirow-projects
/
swarms
mirror of https://github.com/kyegomez/swarms
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1057 from aparekh02/master

Browse Source 
MCP Agent Tool  Docs (with Single Agent and Multi Agent [Sequential])
pull/1064/head
Kye Gomez 1 month ago committed by GitHub
parent c86869b629 5675235554
commit cd75b19127
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 589 additions and 0 deletions
Show Stats Download Patch File Download Diff File

356
docs/examples/mcp_ds.md
Unescape View File

@ -0,0 +1,356 @@
# MCP Agent Tool Documentation
## Introduction to MCP and Agent Running
The Model Context Protocol (MCP) provides a standardized way to create and manage AI agents through a server-client architecture. Running agents on MCP offers several key benefits:
| Benefit | Description |
|------------------------|-----------------------------------------------------------------------------|
| Standardized Interface | Consistent API for agent creation and management across different systems |
| Scalability | Handle multiple agents simultaneously through a single MCP server |
| Interoperability | Agents can be called from any MCP-compatible client |
| Resource Management | Centralized control over agent lifecycle and resources |
| Protocol Compliance | Follows the established MCP standard for AI tool integration |
## Step 1: Setup and Installation
### Prerequisites
| Requirement |
|-----------------------|
| Python 3.8 or higher |
| pip package manager |
### Required Packages
Install the necessary packages using pip:
```bash
# Install MCP SDK and FastMCP
pip install mcp fastmcp
# Install Swarms framework
pip install swarms
# Install additional dependencies
pip install loguru
```
### Verify Installation
```python
# Test imports
from mcp.server.fastmcp import FastMCP
from swarms import Agent
print("MCP and Swarms installed successfully!")
```
## Step 2: MCP Server Setup
Create the MCP server file that will handle agent creation requests:
```python
from mcp.server.fastmcp import FastMCP
from swarms import Agent
mcp = FastMCP("MCPAgentTool")
@mcp.tool(
name="create_agent",
description="Create an agent with the specified name, system prompt, and model, then run a task.",
)
def create_agent(agent_name: str, system_prompt: str, model_name: str, task: str) -> str:
"""
Create an agent with the given parameters and execute the specified task.
Args:
agent_name (str): The name of the agent to create.
system_prompt (str): The system prompt to initialize the agent with.
model_name (str): The model name to use for the agent.
task (str): The task for the agent to perform.
Returns:
str: The result of the agent running the given task.
"""
agent = Agent(
agent_name=agent_name,
system_prompt=system_prompt,
model_name=model_name,
)
return agent.run(task)
if __name__ == "__main__":
mcp.run(transport="streamable-http")
```
Save this as `mcp_agent_tool.py` and run it to start the MCP server:
```bash
python mcp_agent_tool.py
```
## Step 3: Basic Client-side Setup: Single Agent
Create a client file to interact with the MCP server and run a single agent:
```python
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import (
streamablehttp_client as http_client,
)
async def create_agent_via_mcp():
"""Create and use an agent through MCP using streamable HTTP."""
print(" Starting MCP client connection...")
# Connect to the MCP server using streamable HTTP
try:
async with http_client("http://localhost:8000/mcp") as (read, write, _):
async with ClientSession(read, write) as session:
try:
await session.initialize()
print("Session initialized successfully!")
except Exception as e:
print(f"Session initialization failed: {e}")
raise
# List available tools
print("Listing available tools...")
try:
tools = await session.list_tools()
print(f" Available tools: {[tool.name for tool in tools.tools]}")
except Exception as e:
print(f"Failed to list tools: {e}")
raise
# Create an agent using your tool
print("Calling create_agent tool...")
try:
arguments = {
"agent_name": "tech_expert",
"system_prompt": "You are a technology expert. Provide clear explanations.",
"model_name": "gpt-4",
"task": "Explain blockchain technology in simple terms"
}
result = await session.call_tool(
name="create_agent",
arguments=arguments
)
# Result Handling
if hasattr(result, 'content') and result.content:
if isinstance(result.content, list):
for content_item in result.content:
if hasattr(content_item, 'text'):
print(content_item.text)
else:
print(content_item)
else:
print(result.content)
else:
print("No content returned from agent")
return result
except Exception as e:
print(f"Tool call failed: {e}")
import traceback
traceback.print_exc()
raise
except Exception as e:
print(f"Connection failed: {e}")
import traceback
traceback.print_exc()
raise
# Run the client
if __name__ == "__main__":
asyncio.run(create_agent_via_mcp())
```
## Step 4: Advanced Client-side Setup: Multiple Agents
Create a multi-agent system that chains multiple agents together for complex workflows:
```python
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import (
streamablehttp_client as http_client,
)
async def create_agent_via_mcp(session, agent_name, system_prompt, model_name, task):
"""Create and use an agent through MCP using streamable HTTP."""
print(f" Creating agent '{agent_name}' with task: {task}")
try:
arguments = {
"agent_name": agent_name,
"system_prompt": system_prompt,
"model_name": model_name,
"task": task
}
result = await session.call_tool(
name="create_agent",
arguments=arguments
)
# Result Handling
output = None
if hasattr(result, 'content') and result.content:
if isinstance(result.content, list):
for content_item in result.content:
if hasattr(content_item, 'text'):
print(content_item.text)
output = content_item.text
else:
print(content_item)
output = content_item
else:
print(result.content)
output = result.content
else:
print("No content returned from agent")
return output
except Exception as e:
print(f"Tool call failed: {e}")
import traceback
traceback.print_exc()
raise
async def main():
print(" Starting MCP client connection...")
try:
async with http_client("http://localhost:8000/mcp") as (read, write, _):
async with ClientSession(read, write) as session:
try:
await session.initialize()
print("Session initialized successfully!")
except Exception as e:
print(f"Session initialization failed: {e}")
raise
# List available tools
print("Listing available tools...")
try:
tools = await session.list_tools()
print(f" Available tools: {[tool.name for tool in tools.tools]}")
except Exception as e:
print(f"Failed to list tools: {e}")
raise
# Sequential Multi-Agent System
# Agent 1: Tech Expert explains blockchain
agent1_name = "tech_expert"
agent1_prompt = "You are a technology expert. Provide clear explanations."
agent1_model = "gpt-4"
agent1_task = "Explain blockchain technology in simple terms"
agent1_output = await create_agent_via_mcp(
session,
agent1_name,
agent1_prompt,
agent1_model,
agent1_task
)
# Agent 2: Legal Expert analyzes the explanation from Agent 1
agent2_name = "legal_expert"
agent2_prompt = "You are a legal expert. Analyze the following explanation for legal implications."
agent2_model = "gpt-4"
agent2_task = f"Analyze the following explanation for legal implications:\n\n{agent1_output}"
agent2_output = await create_agent_via_mcp(
session,
agent2_name,
agent2_prompt,
agent2_model,
agent2_task
)
# Agent 3: Educator simplifies the legal analysis for students
agent3_name = "educator"
agent3_prompt = "You are an educator. Summarize the following legal analysis in simple terms for students."
agent3_model = "gpt-4"
agent3_task = f"Summarize the following legal analysis in simple terms for students:\n\n{agent2_output}"
agent3_output = await create_agent_via_mcp(
session,
agent3_name,
agent3_prompt,
agent3_model,
agent3_task
)
print("\n=== Final Output from Educator Agent ===")
print(agent3_output)
except Exception as e:
print(f"Connection failed: {e}")
import traceback
traceback.print_exc()
raise
# Run the client
if __name__ == "__main__":
asyncio.run(main())
```
## Summary: Complete Setup Steps for Agent Initialization and Setup on MCP
Here's a complete overview of all the steps needed to set up your agent initialization and setup on MCP:
### **Step-by-Step Summary:**
| Step | Description |
|------|-------------|
| 1. Package Installation | Install MCP SDK, FastMCP, Swarms, and dependencies |
| 2. Server Creation | Create the MCP server with agent creation tool |
| 3. Server Startup | Run the MCP server to handle client requests |
| 4. Basic Client | Create a simple client to run single agents |
| 5. Advanced Client | Build multi-agent workflows with sequential processing |
### **What You'll Have After Following These Steps:**
| Component | Description |
|-----------|-------------|
| MCP Server | Running and ready to handle agent creation requests |
| Single Agent Client | For basic agent tasks |
| Multi-Agent Client | For complex, chained workflows |
| Complete System | For dynamic agent creation and management |
| Scalable Architecture | Can handle multiple concurrent agent requests |
### **Key Benefits Achieved:**
| Benefit | Description |
|---------|-------------|
| Standardized Interface | For agent management |
| Scalable Architecture | For multiple agents |
| Protocol Compliance | With MCP standards |
| Resource Management | For efficient agent lifecycle |
| Interoperability | With any MCP-compatible client |
This setup gives you a complete, production-ready system for running AI agents through the Model Context Protocol!
## Connect With Us
If you'd like technical support, join our Discord below and stay updated on our Twitter for new updates!
| Platform | Link | Description |
|----------|------|-------------|
| Documentation | [docs.swarms.world](https://docs.swarms.world) | Official documentation and guides |
| Blog | [Medium](https://medium.com/@kyeg) | Latest updates and technical articles |
| Discord | [Join Discord](https://discord.gg/EamjgSaEQf) | Live chat and community support |
| Twitter | [@kyegomez](https://twitter.com/kyegomez) | Latest news and announcements |
| LinkedIn | [The Swarm Corporation](https://www.linkedin.com/company/the-swarm-corporation) | Professional network and updates |
| YouTube | [Swarms Channel](https://www.youtube.com/channel/UC9yXyitkbU_WSy7bd_41SqQ) | Tutorials and demos |
| Events | [Sign up here](https://lu.ma/5p2jnc2v) | Join our community events |

1
docs/mkdocs.yml
Unescape View File

@ -327,6 +327,7 @@ nav:
- Overview: "swarms_tools/overview.md" - Overview: "swarms_tools/overview.md"
- BaseTool Reference: "swarms/tools/base_tool.md" - BaseTool Reference: "swarms/tools/base_tool.md"
- MCP Client Utils: "swarms/tools/mcp_client_call.md" - MCP Client Utils: "swarms/tools/mcp_client_call.md"
- MCP Agent Tool: "swarms/tools/mcp_agent_tool.md"
- Vertical Tools: - Vertical Tools:
- Finance: "swarms_tools/finance.md" - Finance: "swarms_tools/finance.md"

31
examples/mcp/deploy_mcp_server/mcp_agent_tool.py
Unescape View File

@ -0,0 +1,31 @@
from mcp.server.fastmcp import FastMCP
from swarms import Agent
mcp = FastMCP("MCPAgentTool")
@mcp.tool(
name="create_agent",
description="Create an agent with the specified name, system prompt, and model, then run a task.",
)
def create_agent(agent_name: str, system_prompt: str, model_name: str, task: str) -> str:
"""
Create an agent with the given parameters and execute the specified task.
Args:
agent_name (str): The name of the agent to create.
system_prompt (str): The system prompt to initialize the agent with.
model_name (str): The model name to use for the agent.
task (str): The task for the agent to perform.
Returns:
str: The result of the agent running the given task.
"""
agent = Agent(
agent_name=agent_name,
system_prompt=system_prompt,
model_name=model_name,
)
return agent.run(task)
if __name__ == "__main__":
mcp.run(transport="streamable-http")

121
examples/mcp/deploy_mcp_server/multiagent_client.py
Unescape View File

@ -0,0 +1,121 @@
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import (
streamablehttp_client as http_client,
)
async def create_agent_via_mcp(session, agent_name, system_prompt, model_name, task):
"""Create and use an agent through MCP using streamable HTTP."""
print(f"🔧 Creating agent '{agent_name}' with task: {task}")
try:
arguments = {
"agent_name": agent_name,
"system_prompt": system_prompt,
"model_name": model_name,
"task": task
}
result = await session.call_tool(
name="create_agent",
arguments=arguments
)
# Result Handling
output = None
if hasattr(result, 'content') and result.content:
if isinstance(result.content, list):
for content_item in result.content:
if hasattr(content_item, 'text'):
print(content_item.text)
output = content_item.text
else:
print(content_item)
output = content_item
else:
print(result.content)
output = result.content
else:
print("No content returned from agent")
return output
except Exception as e:
print(f"Tool call failed: {e}")
import traceback
traceback.print_exc()
raise
async def main():
print("🔧 Starting MCP client connection...")
try:
async with http_client("http://localhost:8000/mcp") as (read, write, _):
async with ClientSession(read, write) as session:
try:
await session.initialize()
print("Session initialized successfully!")
except Exception as e:
print(f"Session initialization failed: {e}")
raise
# List available tools
print("Listing available tools...")
try:
tools = await session.list_tools()
print(f"📋 Available tools: {[tool.name for tool in tools.tools]}")
except Exception as e:
print(f"Failed to list tools: {e}")
raise
# Sequential Multi-Agent System
# Agent 1: Tech Expert explains blockchain
agent1_name = "tech_expert"
agent1_prompt = "You are a technology expert. Provide clear explanations."
agent1_model = "gpt-4"
agent1_task = "Explain blockchain technology in simple terms"
agent1_output = await create_agent_via_mcp(
session,
agent1_name,
agent1_prompt,
agent1_model,
agent1_task
)
# Agent 2: Legal Expert analyzes the explanation from Agent 1
agent2_name = "legal_expert"
agent2_prompt = "You are a legal expert. Analyze the following explanation for legal implications."
agent2_model = "gpt-4"
agent2_task = f"Analyze the following explanation for legal implications:\n\n{agent1_output}"
agent2_output = await create_agent_via_mcp(
session,
agent2_name,
agent2_prompt,
agent2_model,
agent2_task
)
# Agent 3: Educator simplifies the legal analysis for students
agent3_name = "educator"
agent3_prompt = "You are an educator. Summarize the following legal analysis in simple terms for students."
agent3_model = "gpt-4"
agent3_task = f"Summarize the following legal analysis in simple terms for students:\n\n{agent2_output}"
agent3_output = await create_agent_via_mcp(
session,
agent3_name,
agent3_prompt,
agent3_model,
agent3_task
)
print("\n=== Final Output from Educator Agent ===")
print(agent3_output)
except Exception as e:
print(f"Connection failed: {e}")
import traceback
traceback.print_exc()
raise
# Run the client
if __name__ == "__main__":
asyncio.run(main())

80
examples/mcp/deploy_mcp_server/singleagent_client.py
Unescape View File

@ -0,0 +1,80 @@
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import (
streamablehttp_client as http_client,
)
async def create_agent_via_mcp():
"""Create and use an agent through MCP using streamable HTTP."""
print("🔧 Starting MCP client connection...")
# Connect to the MCP server using streamable HTTP
try:
async with http_client("http://localhost:8000/mcp") as (read, write, _):
async with ClientSession(read, write) as session:
try:
await session.initialize()
print("Session initialized successfully!")
except Exception as e:
print(f"Session initialization failed: {e}")
raise
# List available tools
print("Listing available tools...")
try:
tools = await session.list_tools()
print(f"📋 Available tools: {[tool.name for tool in tools.tools]}")
except Exception as e:
print(f"Failed to list tools: {e}")
raise
# Create an agent using your tool
print("Calling create_agent tool...")
try:
arguments = {
"agent_name": "tech_expert",
"system_prompt": "You are a technology expert. Provide clear explanations.",
"model_name": "gpt-4",
"task": "Explain blockchain technology in simple terms"
}
result = await session.call_tool(
name="create_agent",
arguments=arguments
)
# Result Handling
if hasattr(result, 'content') and result.content:
if isinstance(result.content, list):
for content_item in result.content:
if hasattr(content_item, 'text'):
print(content_item.text)
else:
print(content_item)
else:
print(result.content)
else:
print("No content returned from agent")
return result
except Exception as e:
print(f"Tool call failed: {e}")
import traceback
traceback.print_exc()
raise
except Exception as e:
print(f"Connection failed: {e}")
import traceback
traceback.print_exc()
raise
# Run the client
if __name__ == "__main__":
asyncio.run(create_agent_via_mcp())
Write Preview
Loading…
Cancel
Save