"Error: unhandled errors in a TaskGroup (1 sub-exception) " while running mcp_client

[kedargh]

I was trying to run the following client.py script -

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import SseMcpToolAdapter, SseServerParams
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from dotenv import load_dotenv

load_dotenv()

async def main() -> None:
try:
# Configure to connect to your local SSE server
server_params = SseServerParams(
url="http://localhost:8080/sse",
headers={"Content-Type": "application/json"},
timeout=30, # Connection timeout in seconds
)

    # Get the translation tool from the server
    adapter = await SseMcpToolAdapter.from_server_params(server_params, "translate")

    # Create an agent that can use the translation tool
    model_client = OpenAIChatCompletionClient(model="gpt-4")
    agent = AssistantAgent(
        name="translator",
        model_client=model_client,
        tools=[adapter],
        system_message="You are a helpful translation assistant.",
    )


    await Console(
        agent.run_stream(
            task="Translate 'Hello, how are you?' to Spanish",
            cancellation_token=CancellationToken()
        )
    )
except Exception as e:
    print(f"Error: {str(e)}")
if name == "main":
asyncio.run(main())

This is a SSE based MCP client. The server file for the same is given below -

server.py -

from transformers import AutoModelForSequenceClassification, AutoTokenizer
from rich.console import Console
from pydantic import BaseModel
from typing import List, Dict, Any
from gnews import GNews
import yfinance as yf
import torch
import httpx
from mcp.server.fastmcp import FastMCP
from mcp.server.sse import SseServerTransport
from mcp.server import Server
from starlette.applications import Starlette
from starlette.requests import Request
from starlette.routing import Mount, Route
import uvicorn
import argparse

Initialize model and tokenizer
model_path = "yiyanghkust/finbert-tone"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForSequenceClassification.from_pretrained(model_path)
model.eval()

Initialize MCP server
mcp = FastMCP("competitive_analysis")

Pydantic models (unchanged)
class news_object_class(BaseModel):
stock: str = None
news: List = []
classification: List = []

class time_series_class(BaseModel):
stock: str = None
opening_price_list: List
daily_high_list: List
daily_low_list: List
stock_price_time_series_list: List
daily_volume_list: List
daily_dividends_list: List
daily_stock_splits: List

class stock_information(BaseModel):
stock: str
company_information: Dict

Tool functions (unchanged except for adding async where needed)
def sentiment_classifier_single_news(news: str) -> str:
"""Single news classification"""
if not news:
return "Neutral"
inputs = tokenizer(news, return_tensors="pt", truncation=True, padding=True)
with torch.no_grad():
outputs = model(**inputs)
logits = outputs.logits
num_classes = logits.shape[1]
if num_classes > 3:
print("Warning: Model outputs more than 3 classes. Truncating logits.")
logits = logits[:, :3]

    predictions = torch.softmax(logits, dim=1)
    label_index = torch.argmax(predictions).item()
labels = ["Neutral", "Positive", "Negative"]
if label_index < 0 or label_index >= len(labels):
    print(f"Warning: Invalid label index {label_index}. Defaulting to 'Neutral'.")
    return "Neutral"

return labels[label_index]
@mcp.tool()
async def news_fetcher(stock_name:str):
"""Only for fetching news for a stock_name"""
google_news = GNews(
language='en',
country='US',
period='1d',
start_date=None,
end_date=None,
max_results=50,
)
news = google_news.get_news(f"{stock_name}")
headlines = []
for single_news in news:
headlines.append(single_news['title'])

for headline in headlines:
    headline = headline.split('-')[0].strip()

return headlines
@mcp.tool()
async def news_classification_procedure(stock:str):
"""Main function tool for news classification"""
news_object = news_object_class()
print("Created News Object")
news_object.stock = stock
news_object.news = await news_fetcher(stock)

classification_results = []
for news in news_object.news:
    classification_results.append(sentiment_classifier_single_news(news))

print("Classification results populated !!!!")
news_object.classification = classification_results

print("Sentiment classification performed here are the results - ")
return news_object
@mcp.tool()
async def yfinance_financial_data_tool(ticker:str):

ticker=str(ticker)+".NS"
data = yf.Ticker(ticker)

actions = {"actions":data.actions}
analyst_pricing = {"analyst_price_targets":data.analyst_price_targets}
balance_sheet = {"balance_sheet":data.balancesheet}
capital_gains = {"capital_gains":data.capital_gains}
cashflow={"cashflow":data.cashflow}
dividends={"dividends":data.dividends}
earnings={"earnings":data.earnings}
earnings_history={"earnings_history":data.earnings_history}
eps_revisions={"eps_revisions":data.eps_revisions}
eps_trend={"eps_trends":data.eps_trend}

fast_info = {"fast_info": data.fast_info}
financials = {"financials": data.financials}
funds_data = {"funds_data": data.funds_data}
growth_estimates = {"growth_estimates": data.growth_estimates}
history_metadata = {"history_metadata": data.history_metadata}
income_stmt = {"income_stmt": data.income_stmt}
incomestmt = {"incomestmt": data.incomestmt}
info = {"info": data.info}
insider_purchases = {"insider_purchases": data.insider_purchases}
insider_roster_holders = {"insider_roster_holders": data.insider_roster_holders}
insider_transactions = {"insider_transactions": data.insider_transactions}
institutional_holders = {"institutional_holders": data.institutional_holders}
isin = {"isin": data.isin}
major_holders = {"major_holders": data.major_holders}
mutualfund_holders = {"mutualfund_holders": data.mutualfund_holders}
news = {"news": data.news}
options = {"options": data.options}
quarterly_balance_sheet = {"quarterly_balance_sheet": data.quarterly_balancesheet}
quarterly_cash_flow = {"quarterly_cash_flow": data.quarterly_cashflow}
quarterly_earnings = {"quarterly_earnings": data.quarterly_earnings}
quarterly_financials = {"quarterly_financials": data.quarterly_financials}
quarterly_income_stmt = {"quarterly_income_stmt": data.quarterly_incomestmt}
recommendations = {"recommendations": data.recommendations}
recommendations_summary = {"recommendations_summary": data.recommendations_summary}
revenue_estimate = {"revenue_estimate": data.revenue_estimate}
sec_filings = {"sec_filings": data.sec_filings}
shares = {"shares": data.shares}
splits = {"splits": data.splits}
sustainability = {"sustainability": data.sustainability}
ttm_cash_flow = {"ttm_cash_flow": data.ttm_cashflow}
ttm_financials = {"ttm_financials": data.ttm_financials}
ttm_income_stmt = {"ttm_income_stmt": data.ttm_incomestmt}
upgrades_downgrades = {"upgrades_downgrades": data.upgrades_downgrades}


output_dictionary = {
f"{ticker} INFORMATION": [
    actions, analyst_pricing, balance_sheet, capital_gains, cashflow, dividends, earnings,
    earnings_history, eps_revisions, eps_trend, fast_info, financials, funds_data,
    growth_estimates, history_metadata, income_stmt, incomestmt, info, insider_purchases,
    insider_roster_holders, insider_transactions, institutional_holders, isin, major_holders,
    mutualfund_holders, news, options, quarterly_balance_sheet, quarterly_cash_flow,
    quarterly_earnings, quarterly_financials, quarterly_income_stmt, recommendations,
    recommendations_summary, revenue_estimate, sec_filings, shares, splits, sustainability,
    ttm_cash_flow, ttm_financials, ttm_income_stmt, upgrades_downgrades
]
}
return output_dictionary

@mcp.tool()
async def stock_info_tool(stock_ticker: str):
stock_ticker=str(stock_ticker)+".NS"
data=yf.Ticker(stock_ticker)
stock_information_object=stock_information()
stock_information_object.stock=stock_ticker
stock_information_object.company_information=data
return stock_information_object

@mcp.tool()
async def time_series_indicators(stock_ticker: str):
stock_ticker = str(stock_ticker) + ".NS"
data = yf.Ticker(stock_ticker)
historical_data = data.history(period="max").reset_index()

open_list = historical_data["Open"].tolist()
high_list = historical_data["High"].tolist()
low_list = historical_data["Low"].tolist()
close_list = historical_data["Close"].tolist()
volume_list = historical_data["Volume"].tolist()
dividends_list = historical_data["Dividends"].tolist()
splits_list = historical_data["Stock Splits"].tolist()

time_series_indicators_object = time_series_class()
time_series_indicators_object.stock = stock_ticker
time_series_indicators_object.opening_price_list = open_list
time_series_indicators_object.daily_high_list = high_list
time_series_indicators_object.daily_low_list = low_list
time_series_indicators_object.stock_price_time_series_list = close_list
time_series_indicators_object.daily_volume_list = volume_list
time_series_indicators_object.daily_dividends_list = dividends_list
time_series_indicators_object.daily_stock_splits = splits_list

return time_series_indicators_object
def create_starlette_app(mcp_server: Server, *, debug: bool = False) -> Starlette:
sse = SseServerTransport("/messages/")

async def handle_sse(request: Request) -> None:
    async with sse.connect_sse(
            request.scope,
            request.receive,
            request._send,  # noqa: SLF001
    ) as (read_stream, write_stream):
        await mcp_server.run(
            read_stream,
            write_stream,
            mcp_server.create_initialization_options(),
        )

return Starlette(
    debug=debug,
    routes=[
        Route("/sse", endpoint=handle_sse),
        Mount("/messages/", app=sse.handle_post_message),
    ],
)
if name == "main":
mcp_server = mcp._mcp_server # noqa: WPS437

parser = argparse.ArgumentParser(description='Run Competitive Analysis MCP SSE Server')
parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
parser.add_argument('--port', type=int, default=8080, help='Port to listen on')
args = parser.parse_args()

# Bind SSE request handling to MCP server
starlette_app = create_starlette_app(mcp_server, debug=True)

print("SERVER STARTED - SSE Mode")
uvicorn.run(starlette_app, host=args.host, port=args.port)

Basically a set of tools hosted on the server.
When I run the "client.py", I get the following error -

"Error: unhandled errors in a TaskGroup (1 sub-exception)"

Please excuse the format of this issue, it's the first time I am writing one :)

[ekzhu]

"Error: unhandled errors in a TaskGroup (1 sub-exception)"

Could you use python 3.11+ because the ExceptionGroup exception cannot be properly printed in earlier version. Also please upgrade to the latest autogen version which has some fixes already for MCP.

[kedargh]

Yeah i tried that. It's working now. Thanks for the help brother @ekzhu