diff --git a/create-table.js b/create-table.js
deleted file mode 100644
index 64c027c..0000000
--- a/create-table.js
+++ /dev/null
@@ -1,68 +0,0 @@
-'use strict';
-
-// Run once to provision the BigQuery tables:
-//   node create-table.js
-
-const { BigQuery } = require('@google-cloud/bigquery');
-const { GoogleAuth, Impersonated } = require('google-auth-library');
-
-const PROJECT = 'calmal';
-const DATASET = 'lending_poc';
-const SA      = process.env.IMPERSONATE_SA || 'lending-poc@calmal.iam.gserviceaccount.com';
-
-const POOL_SCHEMA = [
-  { name: 'id',            type: 'INT64',  mode: 'REQUIRED' },
-  { name: 'reservePubkey', type: 'STRING', mode: 'REQUIRED' },
-  { name: 'symbol',        type: 'STRING', mode: 'REQUIRED' },
-  { name: 'mintAddress',   type: 'STRING', mode: 'REQUIRED' },
-  { name: 'lending',       type: 'STRING', mode: 'REQUIRED' },
-  { name: 'chain',         type: 'STRING', mode: 'REQUIRED' },
-  { name: 'market',        type: 'STRING', mode: 'REQUIRED' },
-];
-
-const SNAPSHOTS_SCHEMA = [
-  { name: 'poolId',        type: 'INT64',     mode: 'REQUIRED' },
-  { name: 'tvl',           type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'utilization',   type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'supplyAPY',     type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'borrowRate',    type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'borrowAPY',     type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'totalBorrowUsd',type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'liquidityUsd',  type: 'NUMERIC',   mode: 'REQUIRED' },
-  { name: 'fetchedAt',     type: 'TIMESTAMP', mode: 'REQUIRED' },
-];
-
-(async () => {
-  const base = new GoogleAuth();
-  const sourceClient = await base.getClient();
-
-  const impersonated = new Impersonated({
-    sourceClient,
-    targetPrincipal: SA,
-    lifetime: 300,
-    targetScopes: ['https://www.googleapis.com/auth/bigquery'],
-  });
-
-  const bq = new BigQuery({ projectId: PROJECT, authClient: impersonated });
-  console.log(`[bq] impersonating ${SA}`);
-
-  const ds = bq.dataset(DATASET);
-
-  for (const name of ['pool', 'snapshots']) {
-    const table = ds.table(name);
-    const [exists] = await table.exists();
-    if (exists) {
-      await table.delete();
-      console.log(`Deleted ${DATASET}.${name}`);
-    }
-  }
-
-  const [pool]      = await ds.createTable('pool',      { schema: POOL_SCHEMA });
-  const [snapshots] = await ds.createTable('snapshots', { schema: SNAPSHOTS_SCHEMA });
-
-  console.log(`Created ${PROJECT}.${DATASET}.${pool.id}`);
-  console.log(`Created ${PROJECT}.${DATASET}.${snapshots.id}`);
-})().catch(err => {
-  console.error(err.message);
-  process.exit(1);
-});
diff --git a/public/index.html b/public/index.html
index a952a31..66d9708 100644
--- a/public/index.html
+++ b/public/index.html
@@ -238,8 +238,12 @@
   </div>
 
   <script>
+    function fmtApy(v) {
+      return v.toFixed(2) + '%';
+    }
+
     function fmtPct(v) {
-      return (v * 100).toFixed(6) + '%';
+      return (v * 100).toFixed(2) + '%';
     }
 
     function fmtUsd(v) {
@@ -268,8 +272,8 @@
         updatedAt: document.getElementById('updatedAt'),
       };
 
-      els.supplyApy.textContent = fmtPct(d.supplyApy);
-      els.borrowApy.textContent = fmtPct(d.borrowApy);
+      els.supplyApy.textContent = fmtApy(d.supplyApy);
+      els.borrowApy.textContent = fmtApy(d.borrowApy);
       els.utilRate.textContent = fmtPct(d.utilizationRate);
       els.totalSupply.textContent = fmtUsd(d.totalSupplyUsd);
       els.totalBorrows.textContent = fmtUsd(d.totalBorrowUsd);
diff --git a/server.ts b/server.ts
index c72f5c5..3f5e929 100644
--- a/server.ts
+++ b/server.ts
@@ -2,14 +2,14 @@ import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { BigQuery, Dataset } from '@google-cloud/bigquery';
+import { BigQuery } from '@google-cloud/bigquery';
 import { GoogleAuth, Impersonated } from 'google-auth-library';
 import { fetchAllProtocolMetrics, fetchPlotData } from './src/fetchers/index.js';
-import type { StandarizedMetric, PoolRow, SnapshotRow } from './src/types.js';
+import type { StandarizedMetric, TokenDataResult } from './src/types.js';
 
 
 const PORT: number = Number(process.env.PORT) || 3000;
-const POLL_MS = 5000;
+const POLL_MS = 300_000;
 
 const BQ_PROJECT: string = process.env.BIGQUERY_PROJECT_ID || 'calmal';
 const BQ_DATASET: string = process.env.BIGQUERY_DATASET || 'lending_poc';
@@ -17,10 +17,43 @@ const BQ_SA: string = process.env.IMPERSONATE_SA || 'lending-poc@calmal.iam.gser
 
 const htmlContent: Buffer = fs.readFileSync(path.join(__dirname, 'public', 'index.html'));
 
-let latestData: { fetchedAt: string } | null = null;
+type TableData = {
+  protocol: string;
+  symbol: string;
+  market: string;
+  collateral: string | null;
+  supplyApy: number;
+  borrowApy: number;
+  utilizationRate: number;
+  totalSupplyUsd: number;
+  totalBorrowUsd: number;
+  liquidityUsd: number;
+  fetchedAt: string;
+  isAggregated: boolean;
+};
+const latestMetricsCache = new Map<string, TableData>();
+let latestData: TableData[] | null = null;
 const clients: Set<http.ServerResponse> = new Set();
-const seenGenericPools: Set<string> = new Set();
 let isPolling = false;
+const knownPools = new Set<number>();
+let globalBQ: BigQuery | null = null;
+let lastFetchedAt: string | null = null;
+
+async function initKnownPools(bq: BigQuery): Promise<void> {
+  try {
+    const [rows] = await bq.query({
+      query: `SELECT id FROM \`${BQ_PROJECT}.${BQ_DATASET}.pool\``
+    }) as unknown as [Array<{ id: number }>];
+    for (const row of rows) {
+      if (row.id != null) {
+        knownPools.add(Number(row.id));
+      }
+    }
+    console.log(`[bq] loaded ${knownPools.size} known pools from database`);
+  } catch (err) {
+    console.warn(`[bq] could not load known pools: ${(err as Error).message}`);
+  }
+}
 
 function formatSSE(data: unknown): string {
   return `event: update\ndata: ${JSON.stringify(data)}\n\n`;
@@ -29,73 +62,157 @@ function formatSSE(data: unknown): string {
 function broadcast(data: unknown): void {
   const msg = formatSSE(data);
   for (const res of clients) {
+    if (res.writableLength > 1024 * 1024) {
+      console.warn('[sse] client buffer full, dropping connection');
+      res.destroy();
+      clients.delete(res);
+      continue;
+    }
     res.write(msg);
   }
 }
 
 function stableGenericPoolId(metric: StandarizedMetric): number {
-  const key = `${metric.mintAddress}:${metric.lending}:${metric.market}`;
-  return parseInt(crypto.createHash('sha256').update(key).digest('hex').slice(0, 8), 16);
+  const key = `${metric.mintAddress}:${metric.lending}:${metric.market}:${metric.collateral || ''}:${metric.isAggregated ? '1' : '0'}`;
+  return parseInt(crypto.createHash('sha256').update(key).digest('hex').slice(0, 13), 16);
+}
+
+function safeNum(v: unknown): number {
+  const n = Number(v);
+  return isFinite(n) ? n : 0;
 }
 
-async function commitGenericPool(ds: Dataset, metric: StandarizedMetric): Promise<void> {
-  const key = `${metric.mintAddress}:${metric.lending}:${metric.market}`;
-  if (seenGenericPools.has(key)) return;
-  seenGenericPools.add(key);
-  const id = stableGenericPoolId(metric);
+async function batchCommitPools(bq: BigQuery, metrics: StandarizedMetric[]): Promise<void> {
+  if (metrics.length === 0) return;
+
+  const newMetrics = metrics.filter(m => !knownPools.has(stableGenericPoolId(m)));
+  if (newMetrics.length === 0) return;
+
+  const rows = newMetrics.map(m => ({
+    id: stableGenericPoolId(m),
+    reservePubkey: m.mintAddress,
+    symbol: m.symbol,
+    mintAddress: m.mintAddress,
+    lending: m.lending,
+    chain: m.chain,
+    market: m.market,
+    collateral: m.collateral || null,
+    isAggregated: m.isAggregated || false
+  }));
+
   try {
-    const row: PoolRow = {
-      id,
-      reservePubkey: metric.mintAddress,
-      symbol: metric.symbol,
-      mintAddress: metric.mintAddress,
-      lending: metric.lending,
-      chain: metric.chain,
-      market: metric.market,
-    };
-    await ds.table('pool').insert([row]);
-    console.log(`[bq] registered generic pool ${key} → id ${id}`);
+    await bq.dataset(BQ_DATASET).table('pool').insert(rows);
+    for (const m of newMetrics) {
+      knownPools.add(stableGenericPoolId(m));
+    }
   } catch (err) {
-    seenGenericPools.delete(key);
-    throw err;
+    console.error(`[bq] failed to insert pools:`, err);
   }
 }
 
-function safeNum(v: unknown): number {
-  const n = Number(v);
-  return isFinite(n) ? n : 0;
+async function batchCommitSnapshots(bq: BigQuery, metrics: StandarizedMetric[], fetchedAt: string): Promise<void> {
+  if (metrics.length === 0) return;
+
+  const rows = metrics.map(m => {
+    const poolId = stableGenericPoolId(m);
+    const tvl = safeNum(m.tvl);
+    const utilF = safeNum(m.utilization) / 100;
+    const borrow = parseFloat((tvl * utilF).toFixed(9));
+    const liquid = parseFloat((tvl - borrow).toFixed(9));
+
+    return {
+      poolId,
+      tvl,
+      utilization: parseFloat(utilF.toFixed(9)),
+      supplyAPY: safeNum(m.supplyAPY),
+      borrowRate: safeNum(m.borrowRate),
+      borrowAPY: safeNum(m.borrowAPY),
+      totalBorrowUsd: borrow,
+      liquidityUsd: liquid,
+      fetchedAt: bq.timestamp(new Date(fetchedAt))
+    };
+  });
+
+  for (let i = 0; i < rows.length; i += 500) {
+    const chunk = rows.slice(i, i + 500);
+    try {
+      await bq.dataset(BQ_DATASET).table('snapshots').insert(chunk);
+    } catch (err) {
+      if (err && (err as any).name === 'PartialFailureError') {
+        console.error(`[bq] Partial insert failures:`, JSON.stringify((err as any).errors, null, 2));
+      } else {
+        console.error(`[bq] failed to insert snapshots:`, err);
+      }
+    }
+  }
 }
 
-async function commitGenericSnapshot(ds: Dataset, metric: StandarizedMetric): Promise<void> {
-  const tvl = safeNum(metric.tvl);
-  const utilF = safeNum(metric.utilization) / 100;
-  const borrow = parseFloat((tvl * utilF).toFixed(9));
-  const liquid = parseFloat((tvl - borrow).toFixed(9));
-  const row: SnapshotRow = {
-    poolId: stableGenericPoolId(metric),
-    tvl: String(tvl),
-    utilization: String(utilF.toFixed(9)),
-    supplyAPY: String(safeNum(metric.supplyAPY)),
-    borrowRate: String(safeNum(metric.borrowRate)),
-    borrowAPY: String(safeNum(metric.borrowAPY)),
-    totalBorrowUsd: String(borrow),
-    liquidityUsd: String(liquid),
-    fetchedAt: new Date().toISOString(),
-  };
-  await ds.table('snapshots').insert([row]);
+function isMetricSafe(m: StandarizedMetric): boolean {
+  if (m.tvl < 0 || m.tvl > 1_000_000_000_000) return false;
+  if (m.utilization < 0 || m.utilization > 100) return false;
+  if (m.supplyAPY < 0 || m.supplyAPY > 1_000_000) return false;
+  if (m.borrowRate < 0 || m.borrowRate > 1_000_000) return false;
+  return true;
 }
 
-async function pollProtocols(ds: Dataset): Promise<void> {
+async function pollProtocols(bq: BigQuery | null, enableDebugDump: boolean = true): Promise<void> {
   if (isPolling) return;
   isPolling = true;
   try {
     const metrics = await fetchAllProtocolMetrics();
     console.log(`[protocols] fetched ${metrics.length} metrics`);
-    latestData = { fetchedAt: new Date().toISOString() };
+    
+    const now = new Date();
+    
+    const safeMetrics = metrics.filter(isMetricSafe);
+    const isoNow = now.toISOString();
+
+    for (const m of safeMetrics) {
+      const tvl = safeNum(m.tvl);
+      const utilF = safeNum(m.utilization) / 100;
+      const borrow = parseFloat((tvl * utilF).toFixed(9));
+      const liquid = parseFloat((tvl - borrow).toFixed(9));
+      
+      const key = `${m.mintAddress}:${m.lending}:${m.market}:${m.collateral || ''}:${m.isAggregated ? '1' : '0'}`;
+      
+      latestMetricsCache.set(key, {
+        protocol: m.lending,
+        symbol: m.symbol,
+        market: m.market,
+        collateral: m.collateral || null,
+        supplyApy: safeNum(m.supplyAPY),
+        borrowApy: safeNum(m.borrowAPY),
+        utilizationRate: utilF,
+        totalSupplyUsd: tvl,
+        totalBorrowUsd: borrow,
+        liquidityUsd: liquid,
+        fetchedAt: isoNow,
+        isAggregated: m.isAggregated || false
+      });
+    }
+
+    latestData = Array.from(latestMetricsCache.values());
+    lastFetchedAt = isoNow;
     broadcast(latestData);
-    for (const metric of metrics) {
-      commitGenericPool(ds, metric).catch((err: Error) => console.error('[bq:generic:pool]', err.message));
-      commitGenericSnapshot(ds, metric).catch((err: Error) => console.error('[bq:generic:snapshot]', err.message));
+    
+    if (enableDebugDump) {
+      const dumpPath = path.join(process.cwd(), 'debug_data.json');
+      fs.writeFileSync(dumpPath, JSON.stringify({
+        fetchedAt: isoNow,
+        totalMetrics: safeMetrics.length,
+        data: safeMetrics
+      }, null, 2));
+      console.log(`[debug] Saved ${safeMetrics.length} metrics to ${dumpPath}`);
+    }
+    
+    if (safeMetrics.length > 0 && bq) {
+      await batchCommitPools(bq, safeMetrics);
+      console.log(`[bq] batch merged pools`);
+      
+      await batchCommitSnapshots(bq, safeMetrics, isoNow);
+      console.log(`[bq] inserted ${safeMetrics.length} snapshots at ${isoNow}`);
+    } else if (safeMetrics.length > 0 && !bq) {
+      console.log(`[warning] Database disabled. Skipped BigQuery insert for ${safeMetrics.length} snapshots.`);
     }
   } catch (err) {
     console.error('[protocols] poll error:', (err as Error).message);
@@ -104,9 +221,69 @@ async function pollProtocols(ds: Dataset): Promise<void> {
   }
 }
 
-// Heartbeat keeps SSE connections alive through proxies
+
+async function queryBigQueryLatest(bq: BigQuery, protocol: string, symbol: string, isAggregated: boolean): Promise<TokenDataResult | null> {
+  const query = `
+    WITH DeduplicatedSnapshots AS (
+      SELECT s.*, p.lending, p.symbol, p.isAggregated
+      FROM \`${BQ_PROJECT}.${BQ_DATASET}.pool\` p
+      JOIN \`${BQ_PROJECT}.${BQ_DATASET}.snapshots\` s ON p.id = s.poolId
+      WHERE LOWER(p.lending) = LOWER(@protocol) 
+        AND LOWER(p.symbol) = LOWER(@symbol)
+        AND p.isAggregated = @isAggregated
+      QUALIFY ROW_NUMBER() OVER (PARTITION BY s.poolId, s.fetchedAt ORDER BY s.fetchedAt DESC) = 1
+    )
+    SELECT 
+      UNIX_SECONDS(fetchedAt) AS date,
+      SUM(tvl) AS tvlUsd,
+      AVG(supplyAPY) AS supplyAPY,
+      AVG(utilization) AS utilization,
+      AVG(borrowRate) AS borrowRate,
+      AVG(borrowAPY) AS borrowAPY
+    FROM DeduplicatedSnapshots
+    GROUP BY fetchedAt
+    ORDER BY fetchedAt ASC
+    LIMIT 1000
+  `;
+  
+  const [rows] = await bq.query({
+    query,
+    params: { protocol, symbol, isAggregated }
+  }) as unknown as [Array<{ date: number; tvlUsd: number; supplyAPY: number; utilization: number | null; borrowRate: number | null; borrowAPY: number | null; }>];
+  
+  if (!rows || rows.length === 0) return null;
+  
+  const history = rows.map(r => ({
+    date: new Date(Number(r.date) * 1000).toISOString(),
+    apy: Number(r.supplyAPY),
+    utilization: r.utilization !== null ? Number(r.utilization) * 100 : null
+  }));
+  
+  const latest = rows[rows.length - 1];
+  const snapshot = {
+    tvl: Number(latest.tvlUsd || 0),
+    supplyAPY: Number(latest.supplyAPY || 0),
+    borrowRate: Number(latest.borrowRate || 0),
+    borrowAPY: Number(latest.borrowAPY || 0),
+    utilization: latest.utilization !== null ? Number(latest.utilization) * 100 : 0
+  };
+  
+  return {
+    source: "BigQuery",
+    poolId: null,
+    matchedSymbol: symbol,
+    history,
+    snapshot
+  };
+}
+
 setInterval(() => {
   for (const res of clients) {
+    if (res.writableLength > 1024 * 1024) {
+      res.destroy();
+      clients.delete(res);
+      continue;
+    }
     res.write(':heartbeat\n\n');
   }
 }, 30_000);
@@ -132,6 +309,7 @@ function handleSSE(req: http.IncomingMessage, res: http.ServerResponse): void {
 
   clients.add(res);
   req.on('close', () => clients.delete(res));
+  res.on('error', () => clients.delete(res));
 }
 
 function requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void {
@@ -145,11 +323,13 @@ function requestHandler(req: http.IncomingMessage, res: http.ServerResponse): vo
     handleSSE(req, res);
   } else if (req.method === 'GET' && pathname === '/health') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ status: 'ok', lastFetchedAt: latestData?.fetchedAt ?? null }));
+    res.end(JSON.stringify({ status: 'ok', lastFetchedAt }));
   } else if (req.method === 'GET' && (pathname === '/chart' || pathname === '/api/chart')) {
     const protocol = urlObj.searchParams.get('protocol') || urlObj.searchParams.get('platform') || '';
     const symbol = urlObj.searchParams.get('symbol') || urlObj.searchParams.get('asset') || '';
     const collateral = urlObj.searchParams.get('collateral') || undefined;
+    const isAggregatedStr = urlObj.searchParams.get('isAggregated');
+    const isAggregated = isAggregatedStr !== 'false' && isAggregatedStr !== '0';
 
     if (!protocol || !symbol) {
       res.writeHead(400, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
@@ -157,7 +337,11 @@ function requestHandler(req: http.IncomingMessage, res: http.ServerResponse): vo
       return;
     }
 
-    fetchPlotData(protocol, symbol, collateral)
+    const fetchPromise = globalBQ 
+      ? queryBigQueryLatest(globalBQ, protocol, symbol, isAggregated).then(data => data || fetchPlotData(protocol, symbol, collateral))
+      : fetchPlotData(protocol, symbol, collateral);
+
+    fetchPromise
       .then((data) => {
         if (!data || (data.history.length === 0 && !data.poolId)) {
           res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8', 'Access-Control-Allow-Origin': '*' });
@@ -180,26 +364,33 @@ function requestHandler(req: http.IncomingMessage, res: http.ServerResponse): vo
 
 
 async function main(): Promise<void> {
-  const base = new GoogleAuth();
-  const sourceClient = await base.getClient();
-
-  const impersonated = new Impersonated({
-    sourceClient,
-    targetPrincipal: BQ_SA,
-    lifetime: 3600,
-    targetScopes: ['https://www.googleapis.com/auth/bigquery'],
-  });
+  let bigquery: BigQuery | null = null;
 
-  const bigquery = new BigQuery({ projectId: BQ_PROJECT, authClient: impersonated });
-  console.log(`[bq] impersonating ${BQ_SA}`);
+  try {
+    const base = new GoogleAuth();
+    const sourceClient = await base.getClient();
+
+    const impersonated = new Impersonated({
+      sourceClient,
+      targetPrincipal: BQ_SA,
+      lifetime: 3600,
+      targetScopes: ['https://www.googleapis.com/auth/bigquery'],
+    });
+
+    bigquery = new BigQuery({ projectId: BQ_PROJECT, authClient: impersonated });
+    console.log(`[bq] impersonating ${BQ_SA}`);
+    globalBQ = bigquery;
+    await initKnownPools(bigquery);
+  } catch (err) {
+    console.warn(`[warning] Could not load Google credentials. Running in local dry-run mode. Error: ${(err as Error).message}`);
+  }
 
-  const ds: Dataset = bigquery.dataset(BQ_DATASET);
   const server = http.createServer(requestHandler);
 
   server.listen(PORT, () => {
     console.log(`[server] listening on port ${PORT}`);
-    pollProtocols(ds);
-    setInterval(() => pollProtocols(ds), POLL_MS);
+    pollProtocols(bigquery, true);
+    setInterval(() => pollProtocols(bigquery, true), POLL_MS);
     if (process.send) process.send('ready');
   });
 
diff --git a/src/create-table.ts b/src/create-table.ts
index 1a7a58d..40cae53 100644
--- a/src/create-table.ts
+++ b/src/create-table.ts
@@ -14,6 +14,8 @@ const POOL_SCHEMA: BQSchemaField[] = [
   { name: 'lending', type: 'STRING', mode: 'REQUIRED' },
   { name: 'chain', type: 'STRING', mode: 'REQUIRED' },
   { name: 'market', type: 'STRING', mode: 'REQUIRED' },
+  { name: 'collateral', type: 'STRING', mode: 'NULLABLE' },
+  { name: 'isAggregated', type: 'BOOLEAN', mode: 'REQUIRED' },
 ];
 
 const SNAPSHOTS_SCHEMA: BQSchemaField[] = [
@@ -54,7 +56,11 @@ const SNAPSHOTS_SCHEMA: BQSchemaField[] = [
   }
 
   const [pool] = await ds.createTable('pool', { schema: POOL_SCHEMA });
-  const [snapshots] = await ds.createTable('snapshots', { schema: SNAPSHOTS_SCHEMA });
+  const [snapshots] = await ds.createTable('snapshots', {
+    schema: SNAPSHOTS_SCHEMA,
+    clustering: { fields: ['poolId'] },
+    timePartitioning: { type: 'DAY', field: 'fetchedAt' },
+  });
 
   console.log(`Created ${PROJECT}.${DATASET}.${pool.id}`);
   console.log(`Created ${PROJECT}.${DATASET}.${snapshots.id}`);
diff --git a/src/fetchers/defillama.ts b/src/fetchers/defillama.ts
index faa1613..08eb152 100644
--- a/src/fetchers/defillama.ts
+++ b/src/fetchers/defillama.ts
@@ -74,6 +74,17 @@ interface DefiLlamaPool {
   apyReward?: number;
   apyBaseBorrow?: number;
   utilization?: number;
+  predictions?: {
+    predictedClass?: string;
+    predictedProbability?: number;
+    binnedConfidence?: number;
+  };
+  mu?: number;
+  sigma?: number;
+  apyMean30d?: number;
+  ilRisk?: string;
+  exposure?: string;
+  stablecoin?: boolean;
 }
 
 interface DefiLlamaChartEntry {
@@ -137,6 +148,12 @@ export async function fetchDefiLlamaPlot(
         supplyAPY: parseFloat(((tokenPool.apyBase ?? 0) + (tokenPool.apyReward ?? 0)).toFixed(2)),
         borrowRate: parseFloat((tokenPool.apyBaseBorrow ?? 0).toFixed(2)),
         utilization: parseFloat((tokenPool.utilization ?? 0).toFixed(2)),
+        predictions: tokenPool.predictions,
+        mu: tokenPool.mu,
+        sigma: tokenPool.sigma,
+        apyMean30d: tokenPool.apyMean30d,
+        ilRisk: tokenPool.ilRisk,
+        exposure: tokenPool.exposure,
       },
     };
   } catch {
diff --git a/src/fetchers/index.ts b/src/fetchers/index.ts
index 59b6629..30da25a 100644
--- a/src/fetchers/index.ts
+++ b/src/fetchers/index.ts
@@ -20,6 +20,54 @@ export {
   fetchDefiLlamaPlot,
 };
 
+function normalizeSymbol(symbol: string): string {
+  return symbol.toUpperCase().replace(/^W(?=[A-Z])/, '');
+}
+
+function aggregateMetrics(metrics: StandarizedMetric[]): StandarizedMetric[] {
+  const groups = new Map<string, StandarizedMetric[]>();
+  for (const m of metrics) {
+    if (m.isAggregated) continue;
+    const sym = normalizeSymbol(m.symbol);
+    const key = `${m.lending}:${sym}`;
+    let list = groups.get(key);
+    if (!list) {
+      list = [];
+      groups.set(key, list);
+    }
+    list.push(m);
+  }
+  
+  const aggregated: StandarizedMetric[] = [];
+  for (const list of groups.values()) {
+    const totalTvl = list.reduce((sum, m) => sum + (m.tvl || 0), 0);
+    if (totalTvl <= 0) continue;
+    
+    const avgSupplyApy = list.reduce((sum, m) => sum + (m.supplyAPY || 0) * (m.tvl || 0), 0) / totalTvl;
+    const avgBorrowApy = list.reduce((sum, m) => sum + (m.borrowAPY || 0) * (m.tvl || 0), 0) / totalTvl;
+    const avgBorrowRate = list.reduce((sum, m) => sum + (m.borrowRate || 0) * (m.tvl || 0), 0) / totalTvl;
+    const avgUtil = list.reduce((sum, m) => sum + (m.utilization || 0) * (m.tvl || 0), 0) / totalTvl;
+    
+    const best = list.reduce((prev, curr) => (curr.tvl || 0) > (prev.tvl || 0) ? curr : prev);
+    
+    aggregated.push({
+      symbol: normalizeSymbol(best.symbol),
+      mintAddress: best.mintAddress,
+      tvl: totalTvl,
+      utilization: avgUtil,
+      supplyAPY: avgSupplyApy,
+      borrowAPY: avgBorrowApy,
+      borrowRate: avgBorrowRate,
+      lending: best.lending,
+      chain: best.chain,
+      market: 'Aggregated',
+      collateral: undefined,
+      isAggregated: true
+    });
+  }
+  return aggregated;
+}
+
 export async function fetchAllProtocolMetrics(): Promise<StandarizedMetric[]> {
   const fetchers: [string, Promise<StandarizedMetric[]>][] = [
     ['kamino',  fetchKaminoMetrics()],
@@ -39,6 +87,9 @@ export async function fetchAllProtocolMetrics(): Promise<StandarizedMetric[]> {
     }
   }
 
+  const aggregated = aggregateMetrics(metrics);
+  metrics.push(...aggregated);
+
   return metrics;
 }
 
@@ -94,7 +145,8 @@ export async function fetchPlotData(
         normProtocol,
       );
       result.snapshot.protocolTotalActiveLoans = totalActiveLoans;
-    } catch {
+    } catch (e) {
+      console.debug(`[fetchers] missing active loans for ${normProtocol}:`, (e as Error).message);
     }
   }
 
diff --git a/src/fetchers/jupiter.ts b/src/fetchers/jupiter.ts
index c128130..3c2c0bc 100644
--- a/src/fetchers/jupiter.ts
+++ b/src/fetchers/jupiter.ts
@@ -86,7 +86,7 @@ async function fetchEarnTokens(): Promise<StandarizedMetric[]> {
         const price = parseFloat(t.asset.price) || 0;
         const totalAssets = Number(t.totalAssets) / Math.pow(10, t.decimals);
         const tvlUsd = totalAssets * price;
-        if (tvlUsd <= 100_000) return null;
+        if (tvlUsd <= 10_000) return null;
 
         const mint = new PublicKey(t.assetAddress);
         const reserve = await fetchTokenReserve(mint);
@@ -140,7 +140,7 @@ export async function fetchJupiterMetrics(): Promise<StandarizedMetric[]> {
       .filter((v) => {
         const supplyPrice = parseFloat(v.supplyToken.price) || 0;
         const supplyUsd = (Number(v.totalSupply) / Math.pow(10, v.supplyToken.decimals)) * supplyPrice;
-        return supplyUsd > 100000;
+        return supplyUsd > 10000;
       })
       .map((v): StandarizedMetric => {
         const borrowPrice = parseFloat(v.borrowToken.price) || 0;
diff --git a/src/fetchers/kamino.ts b/src/fetchers/kamino.ts
index f483d60..f667bec 100644
--- a/src/fetchers/kamino.ts
+++ b/src/fetchers/kamino.ts
@@ -64,7 +64,7 @@ export async function fetchKaminoMetrics(): Promise<StandarizedMetric[]> {
       const marketName = config.name || 'isolated';
 
       return reserves
-        .filter((r) => parseFloat(r.totalSupplyUsd) > 100_000)
+        .filter((r) => parseFloat(r.totalSupplyUsd) > 10_000)
         .map((r): StandarizedMetric => {
           const totalSupplyUsd = parseFloat(r.totalSupplyUsd);
           const totalBorrowUsd = parseFloat(r.totalBorrowUsd);
diff --git a/src/fetchers/morpho.ts b/src/fetchers/morpho.ts
index d1992ac..9f68d12 100644
--- a/src/fetchers/morpho.ts
+++ b/src/fetchers/morpho.ts
@@ -76,7 +76,7 @@ export async function fetchMorphoMetrics(): Promise<StandarizedMetric[]> {
   const markets = await fetchMorphoMarkets();
 
   return markets
-    .filter((m) => m.state.supplyAssetsUsd > 100000)
+    .filter((m) => m.state.supplyAssetsUsd > 10000)
     .map((m): StandarizedMetric => {
       const lltvRaw = m.lltv ? Number(m.lltv) / 1e18 : null;
       return {
@@ -189,6 +189,7 @@ export async function fetchMorphoPlot(
     supplyAPY: parseFloat((latestState.supplyApy * 100).toFixed(2)),
     borrowRate: parseFloat((latestState.borrowApy * 100).toFixed(2)),
     utilization: parseFloat((latestState.utilization * 100).toFixed(2)),
+    lltv: best.lltv ? Number(((Number(best.lltv) / 1e18) * 100).toFixed(2)) : null,
   };
 
   return {
diff --git a/src/fetchers/save.ts b/src/fetchers/save.ts
index 6f8c8a9..11d6569 100644
--- a/src/fetchers/save.ts
+++ b/src/fetchers/save.ts
@@ -10,7 +10,7 @@ import type {
 import { symbolMatches, downsampleToDaily } from './defillama.js';
 
 const SAVE_API = 'https://api.solend.fi';
-const MIN_TVL_USD = 100_000;
+const MIN_TVL_USD = 10_000;
 
 interface SaveHistoryPoint {
   supplyAPY: number;
diff --git a/src/types.ts b/src/types.ts
index 7d6719c..015dc43 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -10,6 +10,7 @@ export type StandarizedMetric = {
   chain: string;
   market: string;
   collateral?: string;
+  isAggregated?: boolean;
   lltv?: number;
   liqThreshold?: number;
   protocolTotalActiveLoans?: number | null;
@@ -132,6 +133,8 @@ export interface PoolRow {
   lending: string;
   chain: string;
   market: string;
+  collateral: string | null;
+  isAggregated: boolean;
 }
 
 export interface SnapshotRow {
@@ -164,12 +167,23 @@ export interface TokenSnapshot {
   borrowRate: number;
   utilization: number;
   protocolTotalActiveLoans?: number | null;
+  predictions?: {
+    predictedClass?: string;
+    predictedProbability?: number;
+    binnedConfidence?: number;
+  };
+  mu?: number;
+  sigma?: number;
+  apyMean30d?: number;
+  ilRisk?: string;
+  exposure?: string;
+  lltv?: number | null;
 }
 
 export interface TokenDataResult {
   history: TokenHistoryPoint[];
-  poolId: string;
-  source: string;
+  poolId: string | null;
+  source: string | null;
   matchedSymbol: string;
   snapshot?: TokenSnapshot | null;
 }