|
|
The root of that “unhandled errors in a TaskGroup (1 sub‑exception)” is simply that your client’s `MCPServerSse.connect()` is failing under the hood (most likely a connection/refused or path‐not‐found error) and AnyIO is wrapping it in a TaskGroup exception. You don’t see the real cause because it gets hidden by AnyIO’s TaskGroup. Here’s how to unmask it and fix it:
|
|
|
|
|
|
---
|
|
|
|
|
|
## 1. Diagnose the real error
|
|
|
Wrap the connect call and print the underlying exception:
|
|
|
|
|
|
```python
|
|
|
async def _test_connect():
|
|
|
server = MCPServerSse(get_server_params())
|
|
|
try:
|
|
|
await server.connect()
|
|
|
await server.cleanup()
|
|
|
return True
|
|
|
except Exception as e:
|
|
|
# Print the actual cause
|
|
|
import traceback; traceback.print_exc()
|
|
|
return False
|
|
|
|
|
|
print(asyncio.run(_test_connect()))
|
|
|
```
|
|
|
|
|
|
You’ll probably see a **connection refused** or **404 on /sse** in the stack trace.
|
|
|
|
|
|
---
|
|
|
|
|
|
## 2. Ensure client and server agree on your SSE endpoint
|
|
|
By default FastMCP serves its SSE stream at `/sse` and messages on `/messages`. If you only pass `url="http://127.0.0.1:8000"` the client will try whatever its default path is (often `/events` or `/stream`). You need to be explicit:
|
|
|
|
|
|
```python
|
|
|
from swarms.tools.mcp_integration import MCPServerSseParams
|
|
|
|
|
|
def get_server_params():
|
|
|
return MCPServerSseParams(
|
|
|
url="http://127.0.0.1:8000",
|
|
|
sse_path="/sse", # <— tell it exactly where the SSE lives
|
|
|
messages_path="/messages", # <— if your server uses /messages for POSTs
|
|
|
headers={
|
|
|
"Content-Type": "application/json",
|
|
|
"Accept": "text/event-stream",
|
|
|
},
|
|
|
timeout=15.0,
|
|
|
sse_read_timeout=60.0,
|
|
|
require_session_id=False, # match your server’s require_session_id
|
|
|
)
|
|
|
```
|
|
|
|
|
|
---
|
|
|
|
|
|
## 3. Don’t manually call `MCPServerSse` unless you need to
|
|
|
Your `test_server_connection()` can more reliably just do a raw HTTP(S) health‑check:
|
|
|
|
|
|
```python
|
|
|
def test_server_connection():
|
|
|
health_url = get_server_params().url + get_server_params().sse_path
|
|
|
try:
|
|
|
r = httpx.get(health_url,
|
|
|
headers={"Accept":"text/event-stream"},
|
|
|
timeout=5.0)
|
|
|
if r.status_code == 200:
|
|
|
logger.info("✅ SSE endpoint is up")
|
|
|
return True
|
|
|
else:
|
|
|
logger.error(f"❌ Unexpected status {r.status_code}")
|
|
|
return False
|
|
|
except Exception as e:
|
|
|
logger.error(f"❌ Connection to SSE endpoint failed: {e}")
|
|
|
return False
|
|
|
```
|
|
|
|
|
|
That way you see immediately if the server is refusing connections or returning 404.
|
|
|
|
|
|
---
|
|
|
|
|
|
## 4. Align your Agent configuration
|
|
|
Once you’ve verified the raw GET to `http://127.0.0.1:8000/sse` is 200, your Agent should work with exactly the same params:
|
|
|
|
|
|
```python
|
|
|
math_agent = Agent(
|
|
|
agent_name="Math Assistant",
|
|
|
agent_description="Friendly math calculator",
|
|
|
system_prompt=MATH_AGENT_PROMPT,
|
|
|
max_loops=1,
|
|
|
model_name="gpt-3.5-turbo",
|
|
|
verbose=True,
|
|
|
mcp_servers=[ get_server_params() ]
|
|
|
)
|
|
|
```
|
|
|
|
|
|
Now when you do `math_agent.run("add 3 and 4")`, the SSE handshake will succeed and you’ll no longer see that TaskGroup error.
|
|
|
|
|
|
---
|
|
|
|
|
|
### TL;DR
|
|
|
1. **Print the real exception** behind the TaskGroup to see “connection refused” or “404.”
|
|
|
2. **Explicitly set** `sse_path="/sse"` (and `messages_path`) in `MCPServerSseParams`.
|
|
|
3. **Health‑check** with a simple `httpx.get("…/sse")` instead of `server.connect()`.
|
|
|
4. Pass those same params straight into your `Agent`.
|
|
|
|
|
|
Once your client is pointing at the exact SSE URL your FastMCP server is serving, the Agent will connect cleanly and you’ll be back to doing math instead of wrestling TaskGroup errors. |
