Refactor: Source-keyed output format across all MCP servers

- MCPs now emit {source: {data: ...}} format directly
- Simplify mcp_client.py normalizers to pass-through
- Update news-basket to source-keyed structure (tavily, nyt, newsapi)
- Update data schema docs to reflect new output format
- Streamline fundamentals orchestrator

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

docs/finnhub_data_schema.md

@@ -1,37 +1,20 @@
-Finnhub Data Schema
-===================
-
-Endpoint: https://finnhub.io/api/v1/company-news
-Method: GET
-
-
-Request Parameters
-
-| field  | type   | description             |
-|--------|--------|-------------------------|
-| symbol | string | Stock ticker            |
-| from   | string | Start date (YYYY-MM-DD) |
-| to     | string | End date (YYYY-MM-DD)   |
-| token  | string | API key                 |
-
-
-Response (array of articles)
-
-| field    | type   | description      |
-|----------|--------|------------------|
-| headline | string | Article headline |
-| summary  | string | Article summary  |
-| url      | string | Article URL      |
-| source   | string | Publisher name   |
-| datetime | int    | Unix timestamp   |
-
-
-Example Result
-
-| field    | value                                |
-|----------|--------------------------------------|
-| headline | "Apple Reports Strong Q4 Earnings"   |
-| summary  | "Apple Inc reported quarterly..."    |
-| url      | "https://bloomberg.com/apple-q4..."  |
-| source   | "Bloomberg"                          |
-| datetime | 1736416200                           |
+## Company News Endpoint
+`GET https://finnhub.io/api/v1/company-news`
+
+## Request Parameters
+```
+symbol
+from      (YYYY-MM-DD)
+to        (YYYY-MM-DD)
+token
+```
+
+## Response Structure
+```
+[]
+  headline
+  summary
+  url
+  source
+  datetime    (Unix timestamp)
+```

docs/fred_data_schema.md

@@ -1,110 +1,55 @@
-FRED Data Schema
-================
-
-Endpoint: https://api.stlouisfed.org/fred/series/observations
-
-
-Raw API Response Structure
---------------------------
-
-Series Info (seriess[0])
-
-| field               | description                            |
-|---------------------|----------------------------------------|
-| id                  | Series identifier                      |
-| title               | Series title                           |
-| units               | Data units                             |
-| frequency           | Update frequency (Daily, Monthly, etc) |
-| seasonal_adjustment | Adjustment type (SA, NSA)              |
-| last_updated        | Last update timestamp                  |
-
-Observation (observations[])
-
-| field          | description             |
-|----------------|-------------------------|
-| realtime_start | Real-time period start  |
-| realtime_end   | Real-time period end    |
-| date           | Observation date        |
-| value          | Data value (string)     |
-
-
-Series Data
------------
-
-GDP Growth (A191RL1Q225SBEA)
-
-| field        | value                                |
-|--------------|--------------------------------------|
-| series_id    | A191RL1Q225SBEA                      |
-| title        | Real Gross Domestic Product          |
-| units        | Percent Change from Preceding Period |
-| frequency    | Quarterly                            |
-| date         | 2025-07-01                           |
-| value        | 4.3                                  |
-| last_updated | 2025-12-23 07:54:34                  |
-
-Interest Rate (FEDFUNDS)
-
-| field        | value                        |
-|--------------|------------------------------|
-| series_id    | FEDFUNDS                     |
-| title        | Federal Funds Effective Rate |
-| units        | Percent                      |
-| frequency    | Monthly                      |
-| date         | 2025-12-01                   |
-| value        | 3.72                         |
-| last_updated | 2026-01-02 15:18:33          |
-
-CPI (CPIAUCSL)
-
-| field        | value                                         |
-|--------------|-----------------------------------------------|
-| series_id    | CPIAUCSL                                      |
-| title        | Consumer Price Index for All Urban Consumers  |
-| units        | Index 1982-1984=100                           |
-| frequency    | Monthly                                       |
-| date         | 2025-11-01                                    |
-| value        | 325.031                                       |
-| last_updated | 2025-12-18 08:03:48                           |
-
-Unemployment (UNRATE)
-
-| field        | value               |
-|--------------|---------------------|
-| series_id    | UNRATE              |
-| title        | Unemployment Rate   |
-| units        | Percent             |
-| frequency    | Monthly             |
-| date         | 2025-12-01          |
-| value        | 4.4                 |
-| last_updated | 2026-01-09 08:10:37 |
-
-VIX (VIXCLS)
-
-| field        | value                      |
-|--------------|----------------------------|
-| series_id    | VIXCLS                     |
-| title        | CBOE Volatility Index: VIX |
-| units        | Index                      |
-| frequency    | Daily, Close               |
-| date         | 2026-01-08                 |
-| value        | 15.45                      |
-| last_updated | 2026-01-09 08:37:39        |
-
-VXN (VXNCLS)
-
-| field        | value                            |
-|--------------|----------------------------------|
-| series_id    | VXNCLS                           |
-| title        | CBOE NASDAQ 100 Volatility Index |
-| units        | Index                            |
-| frequency    | Daily, Close                     |
-| date         | 2026-01-08                       |
-| value        | 20.15                            |
-| last_updated | 2026-01-09 08:37:34              |
-
-
-Time Categories
----------------
-- Macro indicators (GDP, Interest Rate, CPI, Unemployment): date field is observation date
-- Volatility indices (VIX, VXN): date field is market close date
+## Base URL
+`https://api.stlouisfed.org/fred`
+
+## Series Info Endpoint
+`GET /series`
+
+### Query Parameters
+```
+series_id
+api_key
+file_type   (json)
+```
+
+### Response Structure
+```
+seriess[]
+  title
+  units
+  frequency
+```
+
+## Series Observations Endpoint
+`GET /series/observations`
+
+### Query Parameters
+```
+series_id
+api_key
+file_type    (json)
+sort_order   (desc)
+limit
+```
+
+### Response Structure
+```
+observations[]
+  date
+  value
+```
+
+## Series IDs Used
+
+### Macro Basket
+```
+A191RL1Q225SBEA   (GDP growth rate)
+FEDFUNDS          (Federal Funds Rate)
+CPIAUCSL          (Consumer Price Index)
+FPCPITOTLZGUSA    (Inflation rate)
+UNRATE            (Unemployment Rate)
+```
+
+### Volatility Basket
+```
+VIXCLS            (VIX Index)
+```

docs/mcp_data_structure.md

@@ -0,0 +1,144 @@
+# MCP Data Structures
+
+Output schemas for all MCP basket servers.
+
+---
+
+## fundamentals-basket
+
+```python
+"sec_edgar": {
+    "revenue": {"value": 123456000, "end_date": "2024-09-30", "data_type": "USD", "fiscal_year": 2024, "form": "10-K"},
+    "net_income": {"value": ..., "end_date": ..., ...},
+    "gross_profit": {...},
+    "operating_income": {...},
+    "gross_margin_pct": {...},
+    "operating_margin_pct": {...},
+    "net_margin_pct": {...},
+    "eps_basic": {...},
+    "eps_diluted": {...},
+    "total_assets": {...},
+    "total_liabilities": {...},
+    "stockholders_equity": {...},
+    "long_term_debt": {...},
+    "short_term_debt": {...},
+    "total_debt": {...},
+    "cash": {...},
+    "net_debt": {...},
+    "debt_to_equity": {...},
+    "operating_cash_flow": {...},
+    "capital_expenditure": {...},
+    "free_cash_flow": {...},
+    "company_info": {
+        "name": "Apple Inc.",
+        "cik": "0000320193",
+        "sic": "3571",
+        "sic_description": "Electronic Computers",
+        "sector": "Technology",
+        "industry": "Consumer Electronics"
+    }
+},
+"yahoo_finance": {
+    "market_cap": {"value": 3000000000000, "as_of": "2024-10-31"},
+    "enterprise_value": {...},
+    "shares_outstanding": {...},
+    "float_shares": {...},
+    "held_by_insiders_pct": {...},
+    "held_by_institutions_pct": {...}
+}
+```
+
+**Notes:**
+- SEC Edgar metrics vary by sector (banks have different fields than tech companies)
+- Only non-null values are emitted (sparse representation)
+
+---
+
+## valuation-basket
+
+```python
+"yahoo_finance": {
+    "current_price": {"value": 175.50, "as_of": "2024-10-31"},
+    "trailing_pe": {"value": 28.5, "as_of": "2024-10-31"},
+    "forward_pe": {...},
+    "peg_ratio": {...},
+    "price_to_book": {...},
+    "price_to_sales": {...},
+    "dividend_yield": {...},
+    "52_week_high": {...},
+    "52_week_low": {...}
+},
+"alpha_vantage": {
+    "ev_ebitda": {"value": 22.3, "as_of": "2024-10-31"}
+}
+```
+
+---
+
+## volatility-basket
+
+```python
+"fred": {
+    "vix": {"value": 18.5, "data_type": "Daily", "as_of": "2024-10-31"},
+    "vxn": {"value": 22.1, "data_type": "Daily", "as_of": "2024-10-31"}
+},
+"yahoo_finance": {
+    "beta": {"value": 1.25, "data_type": "1Y", "as_of": "2024-10-31"},
+    "historical_volatility": {"value": 0.32, "data_type": "1Y", "as_of": "2024-10-31"},
+    "implied_volatility": {"value": 0.28, "as_of": "2024-10-31"}
+}
+```
+
+---
+
+## macro-basket
+
+```python
+"bea": {
+    "gdp_growth": {"value": 2.8, "period": "Q3 2024", "as_of": "2024-10-31"}
+},
+"bls": {
+    "unemployment_rate": {"value": 3.8, "period": "Oct 2024", "as_of": "2024-10-31"},
+    "cpi_yoy": {"value": 3.2, "period": "Oct 2024", "as_of": "2024-10-31"},
+    "nonfarm_payrolls": {...}
+},
+"fred": {
+    "fed_funds_rate": {"value": 5.33, "as_of": "2024-10-31"},
+    "treasury_10y": {"value": 4.25, "as_of": "2024-10-31"},
+    "treasury_2y": {...},
+    "yield_curve_spread": {...}
+}
+```
+
+---
+
+## news-basket
+
+```python
+"tavily": [
+    {"title": "...", "url": "...", "content": "...", "published_date": "2024-10-31"}
+],
+"nyt": [
+    {"title": "...", "url": "...", "content": "...", "published_date": "2024-10-31"}
+],
+"newsapi": [
+    {"title": "...", "url": "...", "content": "...", "published_date": "2024-10-30"}
+]
+```
+
+**Date field:** `published_date` = actual article publication date (YYYY-MM-DD)
+
+---
+
+## sentiment-basket
+
+```python
+"finnhub": [
+    {"title": "...", "url": "...", "content": "...", "published_date": "2024-10-31"}
+],
+"reddit": [
+    {"title": "...", "url": "...", "content": "...", "published_date": "2024-10-30"}
+]
+```
+
+**Date field:** `published_date` = article/post creation date (YYYY-MM-DD)

docs/newsapi_data_schema.md

@@ -1,41 +1,26 @@
-NewsAPI Data Schema
-===================
-
-Endpoint: https://newsapi.org/v2/everything
-Method: GET
-
-Note: Free tier has 24-hour delay on articles
-
-
-Request Parameters
-
-| field    | type   | description                              |
-|----------|--------|------------------------------------------|
-| apiKey   | string | API key                                  |
-| q        | string | Search query                             |
-| sortBy   | string | "publishedAt", "relevancy", "popularity" |
-| language | string | Language code (e.g., "en")               |
-| pageSize | int    | Results per page (max 100)               |
-
-
-Response (articles[])
-
-| field       | type   | description                 |
-|-------------|--------|-----------------------------|
-| title       | string | Article title               |
-| url         | string | Article URL                 |
-| description | string | Article description         |
-| content     | string | Article content (truncated) |
-| publishedAt | string | ISO date                    |
-| source.name | string | Publisher name              |
-
-
-Example Result
-
-| field       | value                                  |
-|-------------|----------------------------------------|
-| title       | "Apple Announces New Product Line"     |
-| url         | "https://techcrunch.com/apple-new..."  |
-| description | "Apple unveiled its latest products..."|
-| publishedAt | "2025-01-08T10:15:00Z"                 |
-| source.name | "TechCrunch"                           |
+## Endpoint
+`GET https://newsapi.org/v2/everything`
+
+## Request Parameters
+```
+apiKey
+q
+sortBy       (publishedAt, relevancy, popularity)
+language
+pageSize     (1-100)
+domains
+```
+
+## Response Structure
+```
+status
+totalResults
+articles[]
+  title
+  url
+  description
+  content
+  publishedAt
+  source
+    name
+```

docs/nyt_data_schema.md

@@ -1,40 +1,28 @@
-NYT Article Search Data Schema
-==============================
-
-Endpoint: https://api.nytimes.com/svc/search/v2/articlesearch.json
-Method: GET
-
-
-Request Parameters
-
-| field      | type   | description                     |
-|------------|--------|---------------------------------|
-| api-key    | string | API key                         |
-| q          | string | Search query                    |
-| sort       | string | "newest", "oldest", "relevance" |
-| begin_date | string | YYYYMMDD format                 |
-| end_date   | string | YYYYMMDD format                 |
-| page       | int    | Pagination (0-indexed)          |
-
-
-Response (response.docs[])
-
-| field          | type   | description      |
-|----------------|--------|------------------|
-| headline.main  | string | Article headline |
-| web_url        | string | Article URL      |
-| snippet        | string | Article snippet  |
-| lead_paragraph | string | First paragraph  |
-| pub_date       | string | ISO date         |
-| section_name   | string | NYT section      |
-
-
-Example Result
-
-| field          | value                                  |
-|----------------|----------------------------------------|
-| headline.main  | "Apple Stock Surges on Earnings"       |
-| web_url        | "https://nytimes.com/2025/01/apple..." |
-| snippet        | "Apple shares climbed on strong..."    |
-| pub_date       | "2025-01-09T15:30:00Z"                 |
-| section_name   | "Business"                             |
+## Endpoint
+`GET https://api.nytimes.com/svc/search/v2/articlesearch.json`
+
+## Request Parameters
+```
+api-key
+q
+sort          (newest, oldest, relevance)
+page
+begin_date    (YYYYMMDD)
+end_date      (YYYYMMDD)
+fq            (filter query, e.g., news_desk filter)
+```
+
+## Response Structure
+```
+response
+  meta
+    hits
+  docs[]
+    headline
+      main
+    web_url
+    snippet
+    lead_paragraph
+    pub_date
+    section_name
+```

docs/reddit_data_schema.md

@@ -1,39 +1,34 @@
-Reddit Data Schema
-==================
-
-Endpoint: https://www.reddit.com/r/{subreddit}/search.json
-Method: GET
-Subreddits: wallstreetbets, stocks
-
-
-Request Parameters
-
-| field       | type   | description                  |
-| ----------- | ------ | ---------------------------- |
-| q           | string | Search query (ticker)        |
-| sort        | string | "relevance", "new", etc.     |
-| t           | string | Time filter ("week")         |
-| limit       | int    | Max results                  |
-| restrict_sr | string | "true" to limit to subreddit |
-
-
-Response (data.children[].data)
-
-| field       | type   | description      |
-|-------------|--------|------------------|
-| title       | string | Post title       |
-| selftext    | string | Post body text   |
-| ups         | int    | Upvote count     |
-| permalink   | string | Reddit permalink |
-| created_utc | int    | Unix timestamp   |
-
-
-Example Result
-
-| field       | value                                     |
-|-------------|-------------------------------------------|
-| title       | "AAPL earnings crush - bullish long term" |
-| selftext    | "Just saw the Q4 numbers and..."          |
-| ups         | 2450                                      |
-| permalink   | "/r/stocks/comments/abc123/..."           |
-| created_utc | 1736351400                                |
+## Search Endpoint
+`GET https://www.reddit.com/r/{subreddit}/search.json`
+
+## Request Parameters
+```
+q
+sort          (relevance, top, new, comments)
+t             (week, month, all)
+limit         (1-100)
+restrict_sr   (true/false)
+```
+
+## Request Headers
+```
+User-Agent    (required)
+```
+
+## Response Structure
+```
+data
+  children[]
+    data
+      title
+      selftext
+      permalink
+      ups
+      created_utc
+```
+
+## Subreddits Searched
+```
+wallstreetbets
+stocks
+```

docs/tavily_data_schema.md

@@ -1,40 +1,26 @@
-Tavily Data Schema
-==================
-
-Endpoint: https://api.tavily.com/search
-Method: POST
-
-
-Request Parameters
-
-| field           | type   | description                 |
-|-----------------|--------|-----------------------------|
-| api_key         | string | API key                     |
-| query           | string | Search query                |
-| search_depth    | string | "basic" or "advanced"       |
-| max_results     | int    | 1-10 results                |
-| include_answer  | bool   | Include AI-generated answer |
-| include_domains | array  | Limit to specific domains   |
-| exclude_domains | array  | Exclude specific domains    |
-
-
-Response (results[])
-
-| field          | type   | description             |
-|----------------|--------|-------------------------|
-| title          | string | Article title           |
-| url            | string | Article URL             |
-| content        | string | Article snippet/content |
-| score          | float  | Relevance score (0-1)   |
-| published_date | string | Publication date        |
-
-
-Example Result
-
-| field          | value                                    |
-|----------------|------------------------------------------|
-| title          | "Apple Q4 Earnings Beat Expectations"    |
-| url            | "https://example.com/apple-earnings"     |
-| content        | "Apple reported revenue of $119.6B..."   |
-| score          | 0.89                                     |
-| published_date | "2025-01-09"                             |
+## Endpoint
+`POST https://api.tavily.com/search`
+
+## Request Fields
+```
+api_key
+query
+search_depth        (basic, advanced)
+max_results         (1-10)
+include_answer
+include_raw_content
+include_domains[]
+exclude_domains[]
+days
+```
+
+## Response Structure
+```
+answer
+results[]
+  title
+  url
+  content
+  score
+  published_date
+```

docs/yahoo_data_schema.md

@@ -1,87 +1,68 @@
-Yahoo Finance Data Schema
-=========================
-
-Example: AAPL (Apple Inc)
-
-Time Categories:
-- Market Time: Real-time price data (regularMarketTime)
-- Fiscal Time: Periodic accounting data (mostRecentQuarter, lastFiscalYearEnd)
-
-
-Company Info
-
-| field    | value              |
-| -------- | ------------------ |
-| longName | Apple Inc.         |
-| address1 | One Apple Park Way |
-| city     | Cupertino          |
-| state    | CA                 |
-| country  | United States      |
-
-
-Valuation (Market Time: regularMarketTime)
-
-| field               | value         |
-|---------------------|---------------|
-| regularMarketTime   | 1767992401    |
-| marketCap           | 3832542658560 |
-| enterpriseValue     | 3889336156160 |
-| trailingPE          | 34.721554     |
-| forwardPE           | 28.341707     |
-| enterpriseToEbitda  | 26.87         |
-| enterpriseToRevenue | 9.346         |
-| priceToBook         | 51.967537     |
-
-
-Margins, Returns & Growth (Fiscal Time: mostRecentQuarter)
-
-| field                   | value      |
-|-------------------------|------------|
-| mostRecentQuarter       | 1758931200 |
-| grossMargins            | 0.46905    |
-| ebitdaMargins           | 0.34782    |
-| operatingMargins        | 0.31647    |
-| returnOnEquity          | 1.71422    |
-| returnOnAssets          | 0.22964    |
-| revenueGrowth           | 0.079      |
-| earningsQuarterlyGrowth | 0.864      |
-
-
-Earnings (Fiscal Time: lastFiscalYearEnd / earningsTimestamp)
-
-| field             | value      |
-|-------------------|------------|
-| lastFiscalYearEnd | 1758931200 |
-| trailingEps       | 7.47       |
-| earningsTimestamp | 1769720400 |
-| forwardEps        | 9.15153    |
-
-
-Cash Flow & Liquidity/Debt (Fiscal Time: mostRecentQuarter)
-
-| field             | value        |
-|-------------------|--------------|
-| mostRecentQuarter | 1758931200   |
-| freeCashflow      | 78862254080  |
-| operatingCashflow | 111482003456 |
-| totalCash         | 54697000960  |
-| currentRatio      | 0.893        |
-| quickRatio        | 0.771        |
-| debtToEquity      | 152.411      |
-| totalDebt         | 112377004032 |
-
-
-Risk (Market Time: regularMarketTime)
-
-| field             | value      |
-|-------------------|------------|
-| regularMarketTime | 1767992401 |
-| beta              | 1.093      |
-
-
-Dividends (exDividendDate)
-
-| field          | value      |
-|----------------|------------|
-| exDividendDate | 1762732800 |
-| payoutRatio    | 0.1367     |
+## yfinance Library (Ticker.info)
+
+### Valuation Fields
+```
+currentPrice
+regularMarketPrice
+marketCap
+enterpriseValue
+trailingPE
+forwardPE
+priceToSalesTrailing12Months
+priceToBook
+enterpriseToEbitda
+trailingPegRatio
+earningsGrowth
+revenueGrowth
+```
+### Fundamentals Fallback Fields
+```
+totalRevenue
+netIncomeToCommon
+grossProfits
+operatingIncome
+ebitda
+totalCash
+totalDebt
+freeCashflow
+operatingCashflow
+operatingMargins
+profitMargins
+debtToEquity
+longName
+shortName
+sector
+industry
+```
+## Chart API
+
+### Endpoint
+`GET https://query1.finance.yahoo.com/v8/finance/chart/{ticker}`
+### Query Parameters
+```
+interval   (1d)
+range      (1y, 3mo, 5d, 1d)
+```
+### Response Structure
+```
+chart
+  result[]
+    meta
+      regularMarketPrice
+      previousClose
+    indicators
+      quote[]
+        close[]
+```
+## Options API
+### Endpoint
+`GET https://query1.finance.yahoo.com/v7/finance/options/{ticker}`
+### Response Structure
+```
+optionChain
+  result[]
+    options[]
+      calls[]
+        strike
+        impliedVolatility
+```

mcp-servers/fundamentals-basket/models/schemas.py

@@ -181,16 +181,12 @@ class ParsedFinancials:
     royalty_expense: Optional[TemporalMetric] = None
 
     def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        result = {
-            "ticker": self.ticker,
-            "source": self.source,
-            "as_of": self.as_of,
-            "sector": self.sector,
-        }
+        """Convert to dictionary for JSON serialization.
 
-        if self.sic_code:
-            result["sic_code"] = self.sic_code
+        Only emits metrics (no redundant metadata like ticker, source, sector).
+        Metadata is provided via company_info in the orchestrator.
+        """
+        result = {}
 
         # Add temporal metrics - universal fields
         for field_name in [
@@ -265,12 +261,8 @@ class DebtMetrics:
     as_of: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
 
     def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        result = {
-            "ticker": self.ticker,
-            "source": self.source,
-            "as_of": self.as_of,
-        }
+        """Convert to dictionary for JSON serialization. Only emits metrics."""
+        result = {}
 
         for field_name in [
             "long_term_debt", "short_term_debt", "total_debt",
@@ -295,12 +287,8 @@ class CashFlowMetrics:
     as_of: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
 
     def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        result = {
-            "ticker": self.ticker,
-            "source": self.source,
-            "as_of": self.as_of,
-        }
+        """Convert to dictionary for JSON serialization. Only emits metrics."""
+        result = {}
 
         for field_name in [
             "operating_cash_flow", "capital_expenditure",

mcp-servers/fundamentals-basket/services/orchestrator.py

@@ -381,42 +381,27 @@ class OrchestratorService:
 
         sec_result, yahoo_result = await asyncio.gather(sec_task, yahoo_task)
 
-        # Build normalized source_comparison schema
+        # Build flat source structure (no "data" wrapper)
         sources = {}
-        sec_failed = "error" in sec_result or not sec_result.get("data")
+        sec_failed = "error" in sec_result or not sec_result
 
         # Add SEC EDGAR data if available
         if not sec_failed:
-            sources["sec_edgar"] = {
-                "source": sec_result.get("source"),
-                "data": sec_result.get("data"),
-            }
+            sources["sec_edgar"] = sec_result
 
         # Add Yahoo Finance data
         if "error" not in yahoo_result:
             if sec_failed:
                 # FALLBACK: Yahoo provides core + supplementary when SEC fails
                 yahoo_data = await self._get_yahoo_fallback_data(ticker)
-                if yahoo_data.get("data"):
+                if yahoo_data and "error" not in yahoo_data:
                     sources["yahoo_finance"] = yahoo_data
-            elif yahoo_result.get("data"):
+            elif yahoo_result:
                 # SUPPLEMENTARY: Only additional metrics
-                sources["yahoo_finance"] = {
-                    "source": yahoo_result.get("source"),
-                    "data": yahoo_result.get("data"),
-                }
-
-        # Get company info for response (includes business_address)
-        company_info = await self.get_company_info(ticker)
+                sources["yahoo_finance"] = yahoo_result
 
-        return {
-            "group": "source_comparison",
-            "ticker": ticker,
-            "company": company_info,
-            "sources": sources,
-            "source": "fundamentals-basket",
-            "as_of": datetime.now().strftime("%Y-%m-%d"),
-        }
+        # Return flat {source: metrics} structure
+        return sources
 
     async def _get_sec_data_safe(self, ticker: str) -> Dict[str, Any]:
         """Get SEC data with error handling. Returns universal + industry-specific metrics."""
@@ -435,126 +420,30 @@ class OrchestratorService:
             sector = get_sector_from_sic(sic_code)
 
             financials = self.parser.parse_financials(facts, ticker, sector=sector, sic_code=sic_code)
+            debt = self.parser.parse_debt_metrics(facts, ticker)
+            cash_flow = self.parser.parse_cash_flow(facts, ticker)
 
-            # Helper to convert TemporalMetric to dict (include all temporal fields)
-            def to_metric_dict(tm):
-                if tm is None:
-                    return None
-                return {
-                    "value": tm.value,
-                    "end_date": tm.end_date,
-                    "data_type": tm.data_type,
-                    "fiscal_year": tm.fiscal_year,
-                    "form": tm.form,
-                }
+            # Use to_dict() to emit ALL metrics (universal + sector-specific)
+            # Only non-null values are included (sparse representation)
+            data = financials.to_dict()
 
-            # Universal metrics (works across all industries)
-            data = {
-                "revenue": to_metric_dict(financials.revenue),
-                "net_income": to_metric_dict(financials.net_income),
-                "net_margin_pct": to_metric_dict(financials.net_margin_pct),
-                "total_assets": to_metric_dict(financials.total_assets),
-                "total_liabilities": to_metric_dict(financials.total_liabilities),
-                "stockholders_equity": to_metric_dict(financials.stockholders_equity),
-            }
+            # Merge debt metrics (debt_to_equity, total_debt, etc.)
+            debt_dict = debt.to_dict()
+            for key in ["long_term_debt", "short_term_debt", "total_debt", "cash", "net_debt", "debt_to_equity"]:
+                if key in debt_dict:
+                    data[key] = debt_dict[key]
 
-            # Add industry-specific metrics if available
-            if sector == "INSURANCE":
-                data.update({
-                    "premiums_earned": to_metric_dict(financials.premiums_earned),
-                    "claims_incurred": to_metric_dict(financials.claims_incurred),
-                    "underwriting_income": to_metric_dict(financials.underwriting_income),
-                    "investment_income": to_metric_dict(financials.investment_income),
-                })
-            elif sector == "BANKS":
-                data.update({
-                    "net_interest_income": to_metric_dict(financials.net_interest_income),
-                    "provision_credit_losses": to_metric_dict(financials.provision_credit_losses),
-                    "noninterest_income": to_metric_dict(financials.noninterest_income),
-                    "deposits": to_metric_dict(financials.deposits),
-                })
-            elif sector == "REAL_ESTATE":
-                data.update({
-                    "rental_revenue": to_metric_dict(financials.rental_revenue),
-                    "noi": to_metric_dict(financials.noi),
-                    "ffo": to_metric_dict(financials.ffo),
-                })
-            elif sector == "OIL_GAS":
-                data.update({
-                    "oil_gas_revenue": to_metric_dict(financials.oil_gas_revenue),
-                    "production_expense": to_metric_dict(financials.production_expense),
-                    "depletion": to_metric_dict(financials.depletion),
-                })
-            elif sector == "UTILITIES":
-                data.update({
-                    "electric_revenue": to_metric_dict(financials.electric_revenue),
-                    "gas_revenue": to_metric_dict(financials.gas_revenue),
-                    "fuel_cost": to_metric_dict(financials.fuel_cost),
-                })
-            elif sector == "TECHNOLOGY":
-                data.update({
-                    "rd_expense": to_metric_dict(financials.rd_expense),
-                    "deferred_revenue": to_metric_dict(financials.deferred_revenue),
-                    "cost_of_revenue": to_metric_dict(financials.cost_of_revenue),
-                    "goodwill": to_metric_dict(financials.goodwill),
-                })
-            elif sector == "HEALTHCARE":
-                data.update({
-                    "rd_expense": to_metric_dict(financials.rd_expense),
-                    "cost_of_revenue": to_metric_dict(financials.cost_of_revenue),
-                    "inventory": to_metric_dict(financials.inventory),
-                    "selling_general_admin": to_metric_dict(financials.selling_general_admin),
-                })
-            elif sector == "RETAIL":
-                data.update({
-                    "cost_of_goods_sold": to_metric_dict(financials.cost_of_goods_sold),
-                    "inventory": to_metric_dict(financials.inventory),
-                    "selling_general_admin": to_metric_dict(financials.selling_general_admin),
-                    "depreciation": to_metric_dict(financials.depreciation),
-                })
-            elif sector == "FINANCIALS":
-                data.update({
-                    "advisory_fees": to_metric_dict(financials.advisory_fees),
-                    "trading_revenue": to_metric_dict(financials.trading_revenue),
-                    "compensation_expense": to_metric_dict(financials.compensation_expense),
-                    "investment_income": to_metric_dict(financials.investment_income),
-                })
-            elif sector == "INDUSTRIALS":
-                data.update({
-                    "cost_of_goods_sold": to_metric_dict(financials.cost_of_goods_sold),
-                    "inventory": to_metric_dict(financials.inventory),
-                    "backlog": to_metric_dict(financials.backlog),
-                    "capital_expenditure": to_metric_dict(financials.capital_expenditure),
-                })
-            elif sector == "TRANSPORTATION":
-                data.update({
-                    "operating_revenue": to_metric_dict(financials.operating_revenue),
-                    "fuel_expense": to_metric_dict(financials.fuel_expense),
-                    "labor_expense": to_metric_dict(financials.labor_expense),
-                    "depreciation": to_metric_dict(financials.depreciation),
-                })
-            elif sector == "MATERIALS":
-                data.update({
-                    "cost_of_goods_sold": to_metric_dict(financials.cost_of_goods_sold),
-                    "inventory": to_metric_dict(financials.inventory),
-                    "depreciation": to_metric_dict(financials.depreciation),
-                    "capital_expenditure": to_metric_dict(financials.capital_expenditure),
-                })
-            elif sector == "MINING":
-                data.update({
-                    "mining_revenue": to_metric_dict(financials.mining_revenue),
-                    "cost_of_production": to_metric_dict(financials.cost_of_production),
-                    "depletion": to_metric_dict(financials.depletion),
-                    "exploration_expense": to_metric_dict(financials.exploration_expense),
-                })
+            # Merge cash flow metrics (free_cash_flow, operating_cash_flow, etc.)
+            cf_dict = cash_flow.to_dict()
+            for key in ["operating_cash_flow", "capital_expenditure", "free_cash_flow"]:
+                if key in cf_dict:
+                    data[key] = cf_dict[key]
 
-            return {
-                "source": "SEC EDGAR XBRL",
-                "as_of": datetime.now().strftime("%Y-%m-%d"),
-                "sector": sector,
-                "sic_code": sic_code,
-                "data": data,
-            }
+            # Add company_info for sector detection by downstream analyzer
+            data["company_info"] = company_info
+
+            # Return metrics directly (no wrapper)
+            return data
 
         except Exception as e:
             logger.error(f"SEC data fetch failed for {ticker}: {e}")
@@ -563,84 +452,56 @@ class OrchestratorService:
     async def _get_yahoo_data_safe(self, ticker: str) -> Dict[str, Any]:
         """Get Yahoo data with error handling. Returns supplementary metrics only."""
         try:
-            data = await self.fetcher.fetch_yfinance(ticker)
+            raw_data = await self.fetcher.fetch_yfinance(ticker)
 
-            if "error" in data:
-                return {"error": data["error"], "source": "Yahoo Finance"}
+            if "error" in raw_data:
+                return {"error": raw_data["error"]}
 
-            financials, debt, cash_flow = self.parser.parse_yfinance_data(data, ticker)
+            financials, debt, cash_flow = self.parser.parse_yfinance_data(raw_data, ticker)
 
-            # Helper to convert TemporalMetric to dict (include all temporal fields)
-            def to_metric_dict(tm):
-                if tm is None:
-                    return None
-                return {
-                    "value": tm.value,
-                    "end_date": tm.end_date,
-                    "data_type": tm.data_type,
-                    "fiscal_year": tm.fiscal_year,
-                    "form": tm.form,
-                }
+            # Use to_dict() and filter to supplementary metrics only
+            result = {}
+            fin_dict = financials.to_dict()
+            for key in ["operating_margin_pct", "gross_margin_pct"]:
+                if key in fin_dict:
+                    result[key] = fin_dict[key]
 
-            # Only supplementary metrics not in SEC EDGAR (avoid duplicates)
-            return {
-                "source": "Yahoo Finance",
-                "as_of": datetime.now().strftime("%Y-%m-%d"),
-                "data": {
-                    "operating_margin_pct": to_metric_dict(financials.operating_margin_pct),
-                    "total_debt": to_metric_dict(debt.total_debt) if hasattr(debt, 'total_debt') else None,
-                    "operating_cash_flow": to_metric_dict(cash_flow.operating_cash_flow) if hasattr(cash_flow, 'operating_cash_flow') else None,
-                    "free_cash_flow": to_metric_dict(cash_flow.free_cash_flow) if hasattr(cash_flow, 'free_cash_flow') else None,
-                },
-            }
+            debt_dict = debt.to_dict()
+            for key in ["total_debt"]:
+                if key in debt_dict:
+                    result[key] = debt_dict[key]
+
+            cf_dict = cash_flow.to_dict()
+            for key in ["operating_cash_flow", "free_cash_flow"]:
+                if key in cf_dict:
+                    result[key] = cf_dict[key]
+
+            return result
 
         except Exception as e:
             logger.error(f"Yahoo data fetch failed for {ticker}: {e}")
-            return {"error": str(e), "source": "Yahoo Finance"}
+            return {"error": str(e)}
 
     async def _get_yahoo_fallback_data(self, ticker: str) -> Dict[str, Any]:
         """Get Yahoo data as fallback when SEC fails. Returns core + supplementary metrics."""
         try:
-            data = await self.fetcher.fetch_yfinance(ticker)
+            raw_data = await self.fetcher.fetch_yfinance(ticker)
 
-            if "error" in data:
-                return {"error": data["error"], "source": "Yahoo Finance"}
+            if "error" in raw_data:
+                return {"error": raw_data["error"]}
 
-            financials, debt, cash_flow = self.parser.parse_yfinance_data(data, ticker)
+            financials, debt, cash_flow = self.parser.parse_yfinance_data(raw_data, ticker)
 
-            # Helper to convert TemporalMetric to dict (include all temporal fields)
-            def to_metric_dict(tm):
-                if tm is None:
-                    return None
-                return {
-                    "value": tm.value,
-                    "end_date": tm.end_date,
-                    "data_type": tm.data_type,
-                    "fiscal_year": tm.fiscal_year,
-                    "form": tm.form,
-                }
+            # FALLBACK: Use to_dict() for all metrics
+            result = financials.to_dict()
+            result.update(debt.to_dict())
+            result.update(cash_flow.to_dict())
 
-            # FALLBACK: Core metrics + supplementary metrics
-            return {
-                "source": "Yahoo Finance",
-                "as_of": datetime.now().strftime("%Y-%m-%d"),
-                "data": {
-                    # Core metrics (normally from SEC)
-                    "revenue": to_metric_dict(financials.revenue),
-                    "net_income": to_metric_dict(financials.net_income),
-                    "net_margin_pct": to_metric_dict(financials.net_margin_pct),
-                    "total_assets": to_metric_dict(debt.total_assets) if hasattr(debt, 'total_assets') else None,
-                    # Supplementary metrics
-                    "operating_margin_pct": to_metric_dict(financials.operating_margin_pct),
-                    "total_debt": to_metric_dict(debt.total_debt) if hasattr(debt, 'total_debt') else None,
-                    "operating_cash_flow": to_metric_dict(cash_flow.operating_cash_flow) if hasattr(cash_flow, 'operating_cash_flow') else None,
-                    "free_cash_flow": to_metric_dict(cash_flow.free_cash_flow) if hasattr(cash_flow, 'free_cash_flow') else None,
-                },
-            }
+            return result
 
         except Exception as e:
             logger.error(f"Yahoo fallback fetch failed for {ticker}: {e}")
-            return {"error": str(e), "source": "Yahoo Finance"}
+            return {"error": str(e)}
 
     # =========================================================================
     # HELPER METHODS

mcp-servers/fundamentals-basket/services/parser.py

@@ -354,7 +354,9 @@ class ParserService:
             ParsedFinancials with all metrics (universal + industry-specific)
         """
         # Extract core metrics (universal)
-        revenue = self.get_latest_value(facts, REVENUE_CONCEPTS)
+        # Use get_most_recent_across_concepts for revenue to ensure freshest data
+        # (some companies have ASC 606 concept stale while legacy "Revenues" is current)
+        revenue = self.get_most_recent_across_concepts(facts, REVENUE_CONCEPTS)
         net_income = self.get_latest_value(facts, NET_INCOME_CONCEPTS)
         gross_profit = self.get_latest_value(facts, GROSS_PROFIT_CONCEPTS)
         operating_income = self.get_latest_value(facts, OPERATING_INCOME_CONCEPTS)

mcp-servers/macro-basket/server.py

@@ -42,6 +42,46 @@ import httpx
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("macro-basket")
 
+
+def normalize_date_to_iso(date_str: str) -> str:
+    """
+    Normalize various date formats to YYYY-MM-DD.
+
+    Examples:
+    - "2025Q3" → "2025-09-30" (end of Q3)
+    - "2025-November" → "2025-11-30" (end of month)
+    - "2025-December" → "2025-12-31"
+    - "2025-01" → "2025-01-31"
+    """
+    if not date_str:
+        return None
+
+    # Already in YYYY-MM-DD format
+    if len(date_str) == 10 and date_str[4] == '-' and date_str[7] == '-':
+        return date_str
+
+    # Quarter format: 2025Q3 → 2025-09-30
+    if 'Q' in date_str:
+        year = date_str[:4]
+        quarter = date_str[-1]
+        quarter_end = {'1': '03-31', '2': '06-30', '3': '09-30', '4': '12-31'}
+        return f"{year}-{quarter_end.get(quarter, '12-31')}"
+
+    # Month name format: 2025-November → 2025-11-30
+    month_map = {
+        'January': ('01', '31'), 'February': ('02', '28'), 'March': ('03', '31'),
+        'April': ('04', '30'), 'May': ('05', '31'), 'June': ('06', '30'),
+        'July': ('07', '31'), 'August': ('08', '31'), 'September': ('09', '30'),
+        'October': ('10', '31'), 'November': ('11', '30'), 'December': ('12', '31')
+    }
+    for month_name, (month_num, day) in month_map.items():
+        if month_name in date_str:
+            year = date_str.split('-')[0]
+            return f"{year}-{month_num}-{day}"
+
+    return date_str  # Return as-is if no pattern matches
+
+
 # Initialize MCP server
 server = Server("macro-basket")
 
@@ -805,49 +845,73 @@ async def get_all_sources_macro() -> dict:
         fred_gdp_task, fred_rates_task, fred_cpi_task, fred_unemp_task
     )
 
-    # Use primary source, fallback to secondary if primary failed
-    gdp = bea_gdp if "error" not in bea_gdp else fred_gdp
-    cpi = bls_cpi if "error" not in bls_cpi else fred_cpi
-    unemp = bls_unemp if "error" not in bls_unemp else fred_unemp
-    rates = fred_rates  # FRED is primary for interest rates
+    # Build flat {source: metrics} structure (no "data" wrapper)
+    sources = {}
+    bea_failed = "error" in bea_gdp
+    bls_cpi_failed = "error" in bls_cpi
+    bls_unemp_failed = "error" in bls_unemp
 
-    # Build normalized raw_metrics schema with temporal data
-    return {
-        "group": "raw_metrics",
-        "ticker": "MACRO",
-        "metrics": {
+    # BEA: GDP (if succeeded)
+    if not bea_failed:
+        sources["bea"] = {
             "gdp_growth": {
-                "value": gdp.get("value") if gdp else None,
+                "value": bea_gdp.get("value"),
                 "data_type": "Quarterly",
-                "as_of": gdp.get("date") if gdp else None,  # e.g., "2025Q3"
-                "source": gdp.get("source") if gdp else None,
-                "fallback": gdp.get("fallback", False) if gdp else True
+                "as_of": normalize_date_to_iso(bea_gdp.get("date")),
             },
-            "interest_rate": {
-                "value": rates.get("value") if rates else None,
-                "data_type": "Monthly",
-                "as_of": rates.get("date") if rates else None,
-                "source": rates.get("source") if rates else None,
-                "fallback": rates.get("fallback", False) if rates else True
-            },
-            "cpi_inflation": {
-                "value": cpi.get("value") if cpi else None,
-                "data_type": "Monthly",
-                "as_of": cpi.get("date") if cpi else None,
-                "source": cpi.get("source") if cpi else None,
-                "fallback": cpi.get("fallback", False) if cpi else True
-            },
-            "unemployment": {
-                "value": unemp.get("value") if unemp else None,
-                "data_type": "Monthly",
-                "as_of": unemp.get("date") if unemp else None,
-                "source": unemp.get("source") if unemp else None,
-                "fallback": unemp.get("fallback", False) if unemp else True
-            }
-        },
-        "source": "macro-basket",
-        "as_of": datetime.now().strftime("%Y-%m-%d")
-    }
+        }
+
+    # BLS: CPI and Unemployment (if succeeded)
+    bls_data = {}
+    if not bls_cpi_failed:
+        bls_data["cpi_inflation"] = {
+            "value": bls_cpi.get("value"),
+            "data_type": "Monthly",
+            "as_of": normalize_date_to_iso(bls_cpi.get("date")),
+        }
+    if not bls_unemp_failed:
+        bls_data["unemployment"] = {
+            "value": bls_unemp.get("value"),
+            "data_type": "Monthly",
+            "as_of": normalize_date_to_iso(bls_unemp.get("date")),
+        }
+    if bls_data:
+        sources["bls"] = bls_data
+
+    # FRED: interest_rate (always) + fallbacks for failed BEA/BLS
+    fred_data = {}
+    # Interest rate - FRED is primary
+    if "error" not in fred_rates:
+        fred_data["interest_rate"] = {
+            "value": fred_rates.get("value"),
+            "data_type": "Monthly",
+            "as_of": normalize_date_to_iso(fred_rates.get("date")),
+        }
+    # Fallback: GDP from FRED if BEA failed
+    if bea_failed and "error" not in fred_gdp:
+        fred_data["gdp_growth"] = {
+            "value": fred_gdp.get("value"),
+            "data_type": "Quarterly",
+            "as_of": normalize_date_to_iso(fred_gdp.get("date")),
+        }
+    # Fallback: CPI from FRED if BLS failed
+    if bls_cpi_failed and "error" not in fred_cpi:
+        fred_data["cpi_inflation"] = {
+            "value": fred_cpi.get("value"),
+            "data_type": "Monthly",
+            "as_of": normalize_date_to_iso(fred_cpi.get("date")),
+        }
+    # Fallback: Unemployment from FRED if BLS failed
+    if bls_unemp_failed and "error" not in fred_unemp:
+        fred_data["unemployment"] = {
+            "value": fred_unemp.get("value"),
+            "data_type": "Monthly",
+            "as_of": normalize_date_to_iso(fred_unemp.get("date")),
+        }
+    if fred_data:
+        sources["fred"] = fred_data
+
+    return sources
 
 
 async def get_full_macro_basket() -> dict:

mcp-servers/news-basket/server.py

@@ -401,53 +401,46 @@ async def get_all_sources_news(ticker: str, company_name: str = None) -> dict:
         tavily_task, nyt_task, newsapi_task
     )
 
-    # Combine results
-    all_results = []
-    sources_used = []
+    # Build source-keyed structure
+    result = {}
 
-    # Add Tavily results (inject source name into each article)
+    # Add Tavily results
     if "results" in tavily_result and tavily_result["results"]:
-        for article in tavily_result["results"]:
-            article["source"] = article.get("source") or "Tavily"
-        all_results.extend(tavily_result["results"])
-        sources_used.append("Tavily")
+        result["tavily"] = [
+            {
+                "title": a.get("title"),
+                "url": a.get("url"),
+                "content": a.get("content"),
+                "published_date": normalize_date(a.get("published_date")),
+            }
+            for a in tavily_result["results"]
+        ]
 
-    # Add NYT results (inject source name into each article)
+    # Add NYT results
     if "results" in nyt_result and nyt_result["results"]:
-        for article in nyt_result["results"]:
-            article["source"] = article.get("source") or "NYT"
-        all_results.extend(nyt_result["results"])
-        sources_used.append("NYT")
+        result["nyt"] = [
+            {
+                "title": a.get("title"),
+                "url": a.get("url"),
+                "content": a.get("content") or a.get("snippet"),
+                "published_date": normalize_date(a.get("published_date")),
+            }
+            for a in nyt_result["results"]
+        ]
 
-    # Add NewsAPI results (inject source name into each article)
+    # Add NewsAPI results
     if "results" in newsapi_result and newsapi_result["results"]:
-        for article in newsapi_result["results"]:
-            article["source"] = article.get("source") or "NewsAPI"
-        all_results.extend(newsapi_result["results"])
-        sources_used.append("NewsAPI")
-
-    # Sort by date (most recent first) - deduplication applied downstream
-    all_results.sort(key=lambda x: x.get("published_date", "") or "", reverse=True)
-
-    # Build normalized content_analysis schema
-    items = []
-    for article in all_results:
-        items.append({
-            "title": article.get("title"),
-            "content": article.get("content") or article.get("snippet"),
-            "url": article.get("url"),
-            "datetime": normalize_date(article.get("published_date")),
-            "source": article.get("source"),
-        })
-
-    # Return {source: {data: ...}} structure
-    return {
-        "news_aggregator": {
-            "data": {
-                "items": items,
+        result["newsapi"] = [
+            {
+                "title": a.get("title"),
+                "url": a.get("url"),
+                "content": a.get("content"),
+                "published_date": normalize_date(a.get("published_date")),
             }
-        }
-    }
+            for a in newsapi_result["results"]
+        ]
+
+    return result
 
 
 async def search_going_concern_news(ticker: str, company_name: str = None) -> dict:

mcp-servers/sentiment-basket/server.py

@@ -220,48 +220,34 @@ async def get_all_sources_sentiment(ticker: str, company_name: str = "") -> dict
 
     finnhub, reddit = await asyncio.gather(finnhub_task, reddit_task)
 
-    # Build normalized content_analysis schema
-    items = []
-    sources_used = []
+    # Build source-keyed structure
+    result = {}
 
     # Add Finnhub articles
     if "error" not in finnhub and finnhub.get("articles"):
-        sources_used.append("Finnhub")
-        for article in finnhub.get("articles", []):
-            items.append({
-                "title": article.get("headline"),
-                "content": article.get("summary"),
-                "url": article.get("url"),
-                "datetime": article.get("datetime"),
-                "source": "Finnhub",
-                "subreddit": None,  # Not applicable for Finnhub
-            })
+        result["finnhub"] = [
+            {
+                "title": a.get("headline"),
+                "url": a.get("url"),
+                "content": a.get("summary"),
+                "published_date": a.get("datetime"),
+            }
+            for a in finnhub.get("articles", [])
+        ]
 
     # Add Reddit posts
     if "error" not in reddit and reddit.get("posts"):
-        sources_used.append("Reddit")
-        for post in reddit.get("posts", []):
-            items.append({
-                "title": post.get("title"),
-                "content": post.get("selftext"),
-                "url": post.get("url"),
-                "datetime": post.get("created_utc"),
-                "source": "Reddit",
-                "subreddit": post.get("subreddit"),  # Separate subreddit field
-            })
-
-    # Sort by datetime (most recent first)
-    items.sort(key=lambda x: x.get("datetime") or "", reverse=True)
-
-    return {
-        "group": "content_analysis",
-        "ticker": ticker.upper(),
-        "items": items,
-        "item_count": len(items),
-        "sources_used": sources_used,
-        "source": "sentiment-basket",
-        "as_of": datetime.now().strftime("%Y-%m-%d")
-    }
+        result["reddit"] = [
+            {
+                "title": p.get("title"),
+                "url": p.get("url"),
+                "content": p.get("selftext"),
+                "published_date": p.get("created_utc"),
+            }
+            for p in reddit.get("posts", [])
+        ]
+
+    return result
 
 
 # ============================================================

mcp-servers/valuation-basket/server.py

@@ -643,60 +643,59 @@ async def get_full_valuation_basket(ticker: str) -> dict:
 
 async def get_all_sources_valuation(ticker: str) -> dict:
     """
-    Fetch valuation metrics from Yahoo Finance (primary) with Alpha Vantage fallback.
-    Returns NORMALIZED schema with 11 universal metrics.
+    Fetch valuation metrics from Yahoo Finance (primary) + Alpha Vantage (supplementary).
+
+    - Yahoo succeeds: yahoo_finance (core) + alpha_vantage (supplementary: ev_ebitda)
+    - Yahoo fails: alpha_vantage (core + supplementary)
     """
-    yahoo_result = await fetch_yahoo_quote(ticker)
+    # Fetch both sources in parallel
+    yahoo_task = fetch_yahoo_quote(ticker)
+    alpha_task = fetch_alpha_vantage_quote(ticker)
+    yahoo_result, alpha_result = await asyncio.gather(yahoo_task, alpha_task)
 
-    # Build normalized schema
     sources = {}
+    yahoo_failed = "error" in yahoo_result
 
-    # Yahoo Finance as primary source (11 universal metrics, excludes ev_ebitda)
-    if "error" not in yahoo_result:
+    if not yahoo_failed:
+        # Yahoo core metrics with temporal data (flat, no "data" wrapper)
+        yahoo_as_of = yahoo_result.get("regular_market_time")
         sources["yahoo_finance"] = {
-            "source": "Yahoo Finance",
-            "regular_market_time": yahoo_result.get("regular_market_time"),
-            "data": {
-                "current_price": safe_get(yahoo_result, "current_price"),
-                "market_cap": safe_get(yahoo_result, "market_cap"),
-                "enterprise_value": safe_get(yahoo_result, "enterprise_value"),
-                "trailing_pe": safe_get(yahoo_result, "trailing_pe"),
-                "forward_pe": safe_get(yahoo_result, "forward_pe"),
-                "ps_ratio": safe_get(yahoo_result, "ps_ratio"),
-                "pb_ratio": safe_get(yahoo_result, "pb_ratio"),
-                "trailing_peg": safe_get(yahoo_result, "trailing_peg"),
-                "forward_peg": safe_get(yahoo_result, "forward_peg"),
-                "earnings_growth": safe_get(yahoo_result, "earnings_growth"),
-                "revenue_growth": safe_get(yahoo_result, "revenue_growth"),
-            }
+            "current_price": {"value": safe_get(yahoo_result, "current_price"), "as_of": yahoo_as_of},
+            "market_cap": {"value": safe_get(yahoo_result, "market_cap"), "as_of": yahoo_as_of},
+            "enterprise_value": {"value": safe_get(yahoo_result, "enterprise_value"), "as_of": yahoo_as_of},
+            "trailing_pe": {"value": safe_get(yahoo_result, "trailing_pe"), "as_of": yahoo_as_of},
+            "forward_pe": {"value": safe_get(yahoo_result, "forward_pe"), "as_of": yahoo_as_of},
+            "ps_ratio": {"value": safe_get(yahoo_result, "ps_ratio"), "as_of": yahoo_as_of},
+            "pb_ratio": {"value": safe_get(yahoo_result, "pb_ratio"), "as_of": yahoo_as_of},
+            "trailing_peg": {"value": safe_get(yahoo_result, "trailing_peg"), "as_of": yahoo_as_of},
+            "forward_peg": {"value": safe_get(yahoo_result, "forward_peg"), "as_of": yahoo_as_of},
+            "earnings_growth": {"value": safe_get(yahoo_result, "earnings_growth"), "as_of": yahoo_as_of},
+            "revenue_growth": {"value": safe_get(yahoo_result, "revenue_growth"), "as_of": yahoo_as_of},
         }
+        # Alpha supplementary metrics (ev_ebitda not in Yahoo)
+        if alpha_result and "error" not in alpha_result:
+            alpha_as_of = alpha_result.get("latest_quarter")
+            sources["alpha_vantage"] = {
+                "ev_ebitda": {"value": safe_get(alpha_result, "ev_ebitda"), "as_of": alpha_as_of},
+            }
     else:
-        # Fallback to Alpha Vantage if Yahoo Finance fails
-        alpha_result = await fetch_alpha_vantage_quote(ticker)
+        # Fallback: Alpha provides core + supplementary
         if alpha_result and "error" not in alpha_result:
+            alpha_as_of = alpha_result.get("latest_quarter")
             sources["alpha_vantage"] = {
-                "source": "Alpha Vantage",
-                "latest_quarter": alpha_result.get("latest_quarter"),
-                "data": {
-                    "current_price": safe_get(alpha_result, "current_price"),
-                    "market_cap": safe_get(alpha_result, "market_cap"),
-                    "trailing_pe": safe_get(alpha_result, "trailing_pe"),
-                    "forward_pe": safe_get(alpha_result, "forward_pe"),
-                    "ps_ratio": safe_get(alpha_result, "ps_ratio"),
-                    "pb_ratio": safe_get(alpha_result, "pb_ratio"),
-                    "trailing_peg": safe_get(alpha_result, "trailing_peg"),
-                    "earnings_growth": safe_get(alpha_result, "earnings_growth"),
-                    "revenue_growth": safe_get(alpha_result, "revenue_growth"),
-                }
+                "current_price": {"value": safe_get(alpha_result, "current_price"), "as_of": alpha_as_of},
+                "market_cap": {"value": safe_get(alpha_result, "market_cap"), "as_of": alpha_as_of},
+                "trailing_pe": {"value": safe_get(alpha_result, "trailing_pe"), "as_of": alpha_as_of},
+                "forward_pe": {"value": safe_get(alpha_result, "forward_pe"), "as_of": alpha_as_of},
+                "ps_ratio": {"value": safe_get(alpha_result, "ps_ratio"), "as_of": alpha_as_of},
+                "pb_ratio": {"value": safe_get(alpha_result, "pb_ratio"), "as_of": alpha_as_of},
+                "trailing_peg": {"value": safe_get(alpha_result, "trailing_peg"), "as_of": alpha_as_of},
+                "earnings_growth": {"value": safe_get(alpha_result, "earnings_growth"), "as_of": alpha_as_of},
+                "revenue_growth": {"value": safe_get(alpha_result, "revenue_growth"), "as_of": alpha_as_of},
+                "ev_ebitda": {"value": safe_get(alpha_result, "ev_ebitda"), "as_of": alpha_as_of},
             }
 
-    return {
-        "group": "source_comparison",
-        "ticker": ticker.upper(),
-        "sources": sources,
-        "source": "valuation-basket",
-        "as_of": datetime.now().strftime("%Y-%m-%d")
-    }
+    return sources
 
 
 # ============================================================

mcp-servers/volatility-basket/server.py

@@ -898,51 +898,45 @@ async def get_all_sources_volatility(ticker: str) -> dict:
     hv = yahoo_hv if "error" not in yahoo_hv else (av_hv or yahoo_hv)
     iv = yahoo_iv
 
-    # Build normalized raw_metrics schema with temporal data
-    return {
-        "group": "raw_metrics",
-        "ticker": ticker.upper(),
-        "metrics": {
-            "vix": {
-                "value": vix.get("value"),
-                "data_type": "Daily",
-                "as_of": vix.get("as_of"),  # FRED observation date
-                "source": vix.get("source"),
-                "fallback": vix.get("fallback", False)
-            },
-            "vxn": {
-                "value": vxn.get("value"),
-                "data_type": "Daily",
-                "as_of": vxn.get("as_of"),  # FRED observation date
-                "source": vxn.get("source"),
-                "fallback": vxn.get("fallback", False)
-            },
-            "beta": {
-                "value": beta.get("value") if beta else None,
-                "data_type": "1Y",  # 1 year lookback
-                "as_of": beta.get("as_of") if beta else None,
-                "source": beta.get("source") if beta else None,
-                "fallback": beta.get("fallback", False) if beta else True
-            },
-            "historical_volatility": {
-                "value": hv.get("value") if hv else None,
-                "data_type": "30D",  # 30 day lookback
-                "as_of": hv.get("as_of") if hv else None,
-                "source": hv.get("source") if hv else None,
-                "fallback": hv.get("fallback", False) if hv else True
-            },
-            "implied_volatility": {
-                "value": iv.get("value") if iv else None,
-                "data_type": "Forward",  # Forward-looking from options
-                "as_of": iv.get("as_of") if iv else None,
-                "source": iv.get("source") if iv else None,
-                "fallback": iv.get("fallback", False) if iv else True
-            }
+    # Build flat {source: metrics} structure (no "data" wrapper)
+    sources = {}
+
+    # FRED: VIX and VXN (market volatility context)
+    sources["fred"] = {
+        "vix": {
+            "value": vix.get("value"),
+            "data_type": "Daily",
+            "as_of": vix.get("as_of"),
+        },
+        "vxn": {
+            "value": vxn.get("value"),
+            "data_type": "Daily",
+            "as_of": vxn.get("as_of"),
         },
-        "source": "volatility-basket",
-        "as_of": datetime.now().strftime("%Y-%m-%d")
     }
 
+    # Yahoo Finance: beta, historical_volatility, implied_volatility
+    sources["yahoo_finance"] = {
+        "beta": {
+            "value": beta.get("value") if beta else None,
+            "data_type": "1Y",
+            "as_of": beta.get("as_of") if beta else None,
+        },
+        "historical_volatility": {
+            "value": hv.get("value") if hv else None,
+            "data_type": "30D",
+            "as_of": hv.get("as_of") if hv else None,
+        },
+        "implied_volatility": {
+            "value": iv.get("value") if iv else None,
+            "data_type": "Forward",
+            "as_of": iv.get("as_of") if iv else None,
+            "is_estimated": iv.get("estimated", False) if iv else True,
+        },
+    }
+
+    return sources
+
 
 async def get_full_volatility_basket(ticker: str) -> dict:
     """

mcp_client.py

@@ -427,134 +427,23 @@ async def call_sentiment_mcp(ticker: str, company_name: str = "") -> dict:
 # =============================================================================
 
 def _normalize_volatility(raw: dict) -> dict:
-    """
-    Normalize volatility schema.
-    Input:  {"metrics": {"vix": {...}, "beta": {...}, ...}}
-    Output: {"yahoo_finance": {"data": {...}}, "market_volatility_context": {...}}
-    """
-    if not raw or "error" in raw:
-        return raw
-
-    metrics = raw.get("metrics", {})
-
-    # Extract VIX/VXN for market context
-    vix = metrics.get("vix", {})
-    vxn = metrics.get("vxn", {})
-
-    # Extract stock-specific metrics for yahoo_finance
-    beta = metrics.get("beta", {})
-    hist_vol = metrics.get("historical_volatility", {})
-    impl_vol = metrics.get("implied_volatility", {})
-
-    return {
-        "yahoo_finance": {
-            "source": "Yahoo Finance",
-            "data": {
-                "beta": beta,
-                "historical_volatility": hist_vol,
-                "implied_volatility": impl_vol,
-            }
-        },
-        "market_volatility_context": {
-            "vix": {"value": vix.get("value"), "date": vix.get("as_of")},
-            "vxn": {"value": vxn.get("value"), "date": vxn.get("as_of")},
-        },
-        "source": raw.get("source"),
-        "as_of": raw.get("as_of"),
-    }
+    """Pass-through: MCPs now emit {source: {data: ...}} directly."""
+    return raw
 
 
 def _normalize_macro(raw: dict) -> dict:
-    """
-    Normalize macro schema.
-    Input:  {"metrics": {"gdp_growth": {...}, "interest_rate": {...}, ...}}
-    Output: {"bea_bls": {"data": {...}}, "fred": {"data": {...}}}
-    """
-    if not raw or "error" in raw:
-        return raw
-
-    metrics = raw.get("metrics", {})
-
-    gdp = metrics.get("gdp_growth", {})
-    cpi = metrics.get("cpi_inflation", {})
-    unemp = metrics.get("unemployment", {})
-    interest = metrics.get("interest_rate", {})
-
-    # BEA/BLS: GDP, CPI, unemployment (primary sources)
-    # FRED: interest_rate (and fallback for others)
-    # Note: In get_all_sources_macro, "as_of" field contains the actual data date (e.g., "2025Q3")
-    return {
-        "bea_bls": {
-            "source": "BEA/BLS",
-            "data": {
-                "gdp_growth": {"value": gdp.get("value"), "date": gdp.get("as_of")},
-                "cpi_inflation": {"value": cpi.get("value"), "date": cpi.get("as_of")},
-                "unemployment": {"value": unemp.get("value"), "date": unemp.get("as_of")},
-            }
-        },
-        "fred": {
-            "source": "FRED",
-            "data": {
-                "interest_rate": {"value": interest.get("value"), "date": interest.get("as_of")},
-                "gdp_growth": {"value": gdp.get("value"), "date": gdp.get("as_of")} if gdp.get("fallback") else None,
-                "cpi_inflation": {"value": cpi.get("value"), "date": cpi.get("as_of")} if cpi.get("fallback") else None,
-                "unemployment": {"value": unemp.get("value"), "date": unemp.get("as_of")} if unemp.get("fallback") else None,
-            }
-        },
-        "source": raw.get("source"),
-        "as_of": raw.get("as_of"),
-    }
+    """Pass-through: MCPs now emit {source: {data: ...}} directly."""
+    return raw
 
 
 def _normalize_valuation(raw: dict) -> dict:
-    """
-    Normalize valuation schema.
-    Input:  {"sources": {"yahoo_finance": {...}, "alpha_vantage": {...}}}
-    Output: {"yahoo_finance": {"data": {...}}, "alpha_vantage": {"data": {...}}}
-    """
-    if not raw or "error" in raw:
-        return raw
-
-    sources = raw.get("sources", {})
-
-    result = {
-        "source": raw.get("source"),
-        "as_of": raw.get("as_of"),
-    }
-
-    # Flatten sources to top level
-    if "yahoo_finance" in sources:
-        result["yahoo_finance"] = sources["yahoo_finance"]
-    if "alpha_vantage" in sources:
-        result["alpha_vantage"] = sources["alpha_vantage"]
-
-    return result
+    """Pass-through: MCPs now emit {source: {data: ...}} directly."""
+    return raw
 
 
 def _normalize_fundamentals(raw: dict) -> dict:
-    """
-    Normalize fundamentals schema.
-    Input:  {"sources": {"sec_edgar": {...}, "yahoo_finance": {...}}}
-    Output: {"sec_edgar": {"data": {...}}, "yahoo_finance": {"data": {...}}}
-    """
-    if not raw or "error" in raw:
-        return raw
-
-    sources = raw.get("sources", {})
-
-    result = {
-        "source": raw.get("source"),
-        "as_of": raw.get("as_of"),
-        "ticker": raw.get("ticker"),
-    }
-
-    # Flatten sources to top level
-    if "sec_edgar" in sources:
-        result["sec_edgar"] = sources["sec_edgar"]
-    if "yahoo_finance" in sources:
-        result["yahoo_finance"] = sources["yahoo_finance"]
-
-    return result
+    """Pass-through: MCPs now emit {source: {data: ...}} directly."""
+    return raw
 
 
 def _get_nested_value(data: dict, *keys):