From fc0ba1e37d63e6d6b8b93f39df921fdb90edec5d Mon Sep 17 00:00:00 2001
From: Berack96 <giacomobertolazzi7@gmail.com>
Date: Mon, 29 Sep 2025 21:06:50 +0200
Subject: [PATCH 1/6] Add demo scripts for Coinbase and CryptoCompare; remove
 outdated market agent demo

---
 demos/{example.py => agno_demo.py} |  10 ++-
 demos/cdp_market_demo.py           | 116 -----------------------------
 demos/coinbase_demo.py             |  36 +++++++++
 demos/cryptocompare_demo.py        |  36 +++++++++
 demos/market_agent_demo.py         | 100 -------------------------
 src/app/markets/cryptocompare.py   |   2 +-
 6 files changed, 80 insertions(+), 220 deletions(-)
 rename demos/{example.py => agno_demo.py} (67%)
 delete mode 100644 demos/cdp_market_demo.py
 create mode 100644 demos/coinbase_demo.py
 create mode 100644 demos/cryptocompare_demo.py
 delete mode 100644 demos/market_agent_demo.py

diff --git a/demos/example.py b/demos/agno_demo.py
similarity index 67%
rename from demos/example.py
rename to demos/agno_demo.py
index c1fa08c..38b29ce 100644
--- a/demos/example.py
+++ b/demos/agno_demo.py
@@ -1,3 +1,9 @@
+#### FOR ALL FILES OUTSIDE src/ FOLDER ####
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+###########################################
+
 from agno.agent import Agent
 from agno.models.google import Gemini
 from agno.tools.reasoning import ReasoningTools
@@ -8,9 +14,7 @@ try:
 
     reasoning_agent = Agent(
         model=Gemini(),
-        tools=[
-            ReasoningTools(),
-        ],
+        tools=[ReasoningTools()],
         instructions="Use tables to display data.",
         markdown=True,
     )
diff --git a/demos/cdp_market_demo.py b/demos/cdp_market_demo.py
deleted file mode 100644
index 307d02f..0000000
--- a/demos/cdp_market_demo.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""
-Demo script per testare il MarketAgent aggiornato con Coinbase CDP
-"""
-
-import sys
-import os
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-from src.app.agents.market_agent import MarketAgent
-import logging
-
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-
-def main():
-    print("🚀 Test MarketAgent con Coinbase CDP")
-    print("=" * 50)
-    
-    # Inizializza l'agent
-    agent = MarketAgent()
-    
-    # Verifica provider disponibili
-    providers = agent.get_available_providers()
-    print(f"📡 Provider disponibili: {providers}")
-    
-    if not providers:
-        print("⚠️ Nessun provider configurato. Verifica il file .env")
-        print("\nPer Coinbase CDP, serve:")
-        print("CDP_API_KEY_NAME=your_key_name")
-        print("CDP_API_PRIVATE_KEY=your_private_key")
-        print("\nPer CryptoCompare, serve:")
-        print("CRYPTOCOMPARE_API_KEY=your_api_key")
-        return
-    
-    # Mostra capabilities di ogni provider
-    for provider in providers:
-        capabilities = agent.get_provider_capabilities(provider)
-        print(f"🔧 {provider.upper()}: {capabilities}")
-    
-    print("\n" + "=" * 50)
-    
-    # Test ottenimento prezzo singolo
-    test_symbols = ["BTC", "ETH", "ADA"]
-    
-    for symbol in test_symbols:
-        print(f"\n💰 Prezzo {symbol}:")
-        
-        # Prova ogni provider
-        for provider in providers:
-            try:
-                price = agent.get_asset_price(symbol, provider)
-                if price:
-                    print(f"  {provider}: ${price:,.2f}")
-                else:
-                    print(f"  {provider}: N/A")
-            except Exception as e:
-                print(f"  {provider}: Errore - {e}")
-    
-    print("\n" + "=" * 50)
-    
-    # Test market overview
-    print("\n📊 Market Overview:")
-    try:
-        overview = agent.get_market_overview(["BTC", "ETH", "ADA", "DOT"])
-        
-        if overview["data"]:
-            print(f"📡 Fonte: {overview['source']}")
-            
-            for crypto, prices in overview["data"].items():
-                if isinstance(prices, dict):
-                    usd_price = prices.get("USD", "N/A")
-                    eur_price = prices.get("EUR", "N/A")
-                    
-                    if eur_price != "N/A":
-                        print(f"  {crypto}: ${usd_price} (€{eur_price})")
-                    else:
-                        print(f"  {crypto}: ${usd_price}")
-        else:
-            print("⚠️ Nessun dato disponibile")
-            
-    except Exception as e:
-        print(f"❌ Errore nel market overview: {e}")
-    
-    print("\n" + "=" * 50)
-    
-    # Test funzione analyze
-    print("\n🔍 Analisi mercato:")
-    try:
-        analysis = agent.analyze("Market overview")
-        print(analysis)
-    except Exception as e:
-        print(f"❌ Errore nell'analisi: {e}")
-    
-    # Test specifico Coinbase CDP se disponibile
-    if 'coinbase' in providers:
-        print("\n" + "=" * 50)
-        print("\n🏦 Test specifico Coinbase CDP:")
-        
-        try:
-            # Test asset singolo
-            btc_info = agent.get_coinbase_asset_info("BTC")
-            print(f"📈 BTC Info: {btc_info}")
-            
-            # Test asset multipli
-            multi_assets = agent.get_coinbase_multiple_assets(["BTC", "ETH"])
-            print(f"📊 Multi Assets: {multi_assets}")
-            
-        except Exception as e:
-            print(f"❌ Errore nel test Coinbase CDP: {e}")
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/demos/coinbase_demo.py b/demos/coinbase_demo.py
new file mode 100644
index 0000000..8b6bd41
--- /dev/null
+++ b/demos/coinbase_demo.py
@@ -0,0 +1,36 @@
+#### FOR ALL FILES OUTSIDE src/ FOLDER ####
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+###########################################
+
+from dotenv import load_dotenv
+from app.markets import CoinBaseWrapper
+
+def main():
+    print("Demo Coinbase CDP")
+
+    print("=== Chiavi API ===")
+    print(f"  COINBASE_API_KEY: {os.getenv('COINBASE_API_KEY') is not None}")
+    print(f"  COINBASE_API_SECRET: {os.getenv('COINBASE_API_SECRET') is not None}")
+
+    # Inizializza le API
+    coinbase = CoinBaseWrapper()
+
+    # ottenimento prezzo attuale
+    print("=== Demo prezzo attuale ===")
+    test_symbols = ["BTC", "ETH", "ADA"]
+    for symbol in test_symbols:
+        info = coinbase.get_product(symbol)
+        print(f"  {symbol}: ${info.price:,.2f}")
+
+    # ottenimento prezzi storici
+    print("\n=== Demo prezzi storici ===")
+    test_symbols = ["BTC", "ETH"]
+    for symbol in test_symbols:
+        prices = coinbase.get_historical_prices(symbol)
+        print(f"  {symbol}: {" ".join([f'${entry["price"]:,.2f}' for entry in prices[:5]])}") # mostra solo i primi 5
+
+if __name__ == "__main__":
+    load_dotenv()
+    main()
diff --git a/demos/cryptocompare_demo.py b/demos/cryptocompare_demo.py
new file mode 100644
index 0000000..f929b87
--- /dev/null
+++ b/demos/cryptocompare_demo.py
@@ -0,0 +1,36 @@
+#### FOR ALL FILES OUTSIDE src/ FOLDER ####
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+###########################################
+
+from dotenv import load_dotenv
+from app.markets.cryptocompare import CryptoCompareWrapper
+
+def main():
+    print("Demo CryptoCompare")
+
+    print("=== Chiavi API ===")
+    print(f"  CRYPTOCOMPARE_API_KEY: {os.getenv('CRYPTOCOMPARE_API_KEY') is not None}")
+
+    # Inizializza le API
+    cryptocompare = CryptoCompareWrapper()
+
+    # ottenimento prezzo attuale
+    print("=== Demo prezzo attuale ===")
+    test_symbols = ["BTC", "ETH", "ADA"]
+    for symbol in test_symbols:
+        info = cryptocompare.get_product(symbol)
+        print(f"  {symbol}: ${info.price:,.2f}")
+
+    # ottenimento prezzi storici
+    print("=== Demo prezzi storici ===")
+    test_symbols = ["BTC", "ETH"]
+    for symbol in test_symbols:
+        prices = cryptocompare.get_historical_prices(symbol)
+        prices = [f'[${entry.high:,.2f}-${entry.low:,.2f}]' for entry in prices]
+        print(f"  {symbol}: {" ".join(prices[:5])}") # mostra solo i primi 5
+
+if __name__ == "__main__":
+    load_dotenv()
+    main()
\ No newline at end of file
diff --git a/demos/market_agent_demo.py b/demos/market_agent_demo.py
deleted file mode 100644
index 1ef8f21..0000000
--- a/demos/market_agent_demo.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""
-Esempio di utilizzo del MarketAgent unificato.
-Questo script mostra come utilizzare il nuovo MarketAgent che supporta
-multiple fonti di dati (Coinbase e CryptoCompare).
-"""
-
-import sys
-from pathlib import Path
-
-# Aggiungi il path src al PYTHONPATH
-src_path = Path(__file__).parent / "src"
-sys.path.insert(0, str(src_path))
-
-from dotenv import load_dotenv
-from app.agents.market_agent import MarketAgent
-
-# Carica variabili d'ambiente
-load_dotenv()
-
-def main():
-    print("🚀 Market Agent Demo\n")
-    
-    try:
-        # Inizializza il market agent (auto-configura i provider disponibili)
-        agent = MarketAgent()
-        
-        # Mostra provider disponibili
-        providers = agent.get_available_providers()
-        print(f"📡 Available providers: {providers}")
-        
-        if not providers:
-            print("❌ No providers configured. Please check your .env file.")
-            print("Required variables:")
-            print("  For Coinbase: COINBASE_API_KEY, COINBASE_SECRET, COINBASE_PASSPHRASE")
-            print("  For CryptoCompare: CRYPTOCOMPARE_API_KEY")
-            return
-        
-        # Mostra le capacità di ogni provider
-        print("\n🔧 Provider capabilities:")
-        for provider in providers:
-            capabilities = agent.get_provider_capabilities(provider)
-            print(f"  {provider}: {capabilities}")
-        
-        # Ottieni panoramica del mercato
-        print("\n📊 Market Overview:")
-        overview = agent.get_market_overview(["BTC", "ETH", "ADA"])
-        print(f"Data source: {overview.get('source', 'Unknown')}")
-        
-        for crypto, prices in overview.get('data', {}).items():
-            if isinstance(prices, dict):
-                usd = prices.get('USD', 'N/A')
-                eur = prices.get('EUR', 'N/A')
-                if eur != 'N/A':
-                    print(f"  {crypto}: ${usd} (€{eur})")
-                else:
-                    print(f"  {crypto}: ${usd}")
-        
-        # Analisi completa del mercato
-        print("\n📈 Market Analysis:")
-        analysis = agent.analyze("comprehensive market analysis")
-        print(analysis)
-        
-        # Test specifici per provider (se disponibili)
-        if 'cryptocompare' in providers:
-            print("\n🔸 CryptoCompare specific test:")
-            try:
-                btc_price = agent.get_single_crypto_price("BTC", "USD")
-                print(f"  BTC price: ${btc_price}")
-                
-                top_coins = agent.get_top_cryptocurrencies(5)
-                if top_coins.get('Data'):
-                    print("  Top 5 cryptocurrencies by market cap:")
-                    for coin in top_coins['Data'][:3]:  # Show top 3
-                        coin_info = coin.get('CoinInfo', {})
-                        display = coin.get('DISPLAY', {}).get('USD', {})
-                        name = coin_info.get('FullName', 'Unknown')
-                        price = display.get('PRICE', 'N/A')
-                        print(f"    {name}: {price}")
-            except Exception as e:
-                print(f"  CryptoCompare test failed: {e}")
-        
-        if 'coinbase' in providers:
-            print("\n🔸 Coinbase specific test:")
-            try:
-                ticker = agent.get_coinbase_ticker("BTC-USD")
-                price = ticker.get('price', 'N/A')
-                volume = ticker.get('volume_24h', 'N/A')
-                print(f"  BTC-USD: ${price} (24h volume: {volume})")
-            except Exception as e:
-                print(f"  Coinbase test failed: {e}")
-        
-        print("\n✅ Demo completed successfully!")
-        
-    except Exception as e:
-        print(f"❌ Demo failed: {e}")
-        print("Make sure you have configured at least one provider in your .env file.")
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/src/app/markets/cryptocompare.py b/src/app/markets/cryptocompare.py
index 188a2c2..aa220fa 100644
--- a/src/app/markets/cryptocompare.py
+++ b/src/app/markets/cryptocompare.py
@@ -49,7 +49,7 @@ class CryptoCompareWrapper(BaseWrapper):
     def get_all_products(self) -> list[ProductInfo]:
         raise NotImplementedError("CryptoCompare does not support fetching all assets")
 
-    def get_historical_prices(self, asset_id: str, day_back: int = 10) -> list[dict]:
+    def get_historical_prices(self, asset_id: str, day_back: int = 10) -> list[Price]:
         assert day_back <= 30, "day_back should be less than or equal to 30"
         response = self.__request("/data/v2/histohour", params = {
             "fsym": asset_id,
-- 
2.49.1


From 38b84893797360cb849ac9b976b10b2ebb7cc9ad Mon Sep 17 00:00:00 2001
From: Berack96 <giacomobertolazzi7@gmail.com>
Date: Wed, 22 Oct 2025 09:07:44 +0200
Subject: [PATCH 2/6] remove old docs

---
 docs/Async_Implementation_Detail.md     | 203 ------------------------
 docs/Market_Data_Implementation_Plan.md |  96 -----------
 docs/Piano di Sviluppo.md               |  73 ---------
 3 files changed, 372 deletions(-)
 delete mode 100644 docs/Async_Implementation_Detail.md
 delete mode 100644 docs/Market_Data_Implementation_Plan.md
 delete mode 100644 docs/Piano di Sviluppo.md

diff --git a/docs/Async_Implementation_Detail.md b/docs/Async_Implementation_Detail.md
deleted file mode 100644
index 9642dff..0000000
--- a/docs/Async_Implementation_Detail.md
+++ /dev/null
@@ -1,203 +0,0 @@
-# 🚀 Diagramma Dettaglio: Implementazione Asincrona
-
-## ⚡ Async Market Data Collection (Fase 3)
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                   🔧 TOOL AGENT                                │
-│                                                                 │
-│  async def interact(query, provider, style):                   │
-│      │                                                         │
-│      ├── 📊 market_data = await market_agent.analyze_async()   │
-│      ├── 📰 news_data = await news_agent.analyze_async()       │
-│      ├── 🐦 social_data = await social_agent.analyze_async()   │
-│      │                                                         │
-│      └── 🤖 prediction = await predictor.predict_async(...)    │
-└─────────────────────────────────────────────────────────────────┘
-                               │
-                               ▼
-┌─────────────────────────────────────────────────────────────────┐
-│              📊 MARKET AGENT - ASYNC IMPLEMENTATION             │
-│                                                                 │
-│  async def analyze_async(self, query):                         │
-│      symbols = extract_symbols(query)  # ["BTC", "ETH"]        │
-│      │                                                         │
-│      └── 🔄 tasks = [                                          │
-│          │    self._query_coinbase_async(symbols),             │
-│          │    self._query_cryptocompare_async(symbols),        │
-│          │    self._query_binance_async(symbols)               │
-│          │ ]                                                   │
-│          │                                                     │
-│          └── 📊 results = await asyncio.gather(*tasks)         │
-│                      │                                         │
-│                      ▼                                         │
-│              🧮 aggregate_results(results)                      │
-└─────────────────────────────────────────────────────────────────┘
-                               │
-                               ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                  ⏱️ TIMING DIAGRAM                              │
-│                                                                 │
-│  Time: 0ms    500ms   1000ms  1500ms  2000ms                   │
-│         │       │       │       │       │                     │
-│  📡 Start all requests                                          │
-│         ├─────────────────────────────────────────┐           │
-│         │ 🏦 Coinbase Request                     │           │
-│         │                            ✅ Response │ (1.2s)     │
-│         ├─────────────────────────────┐           │           │
-│         │ 📊 CryptoCompare Request    │           │           │
-│         │                   ✅ Response (0.8s)   │           │
-│         ├─────────────┐               │           │           │
-│         │ 🟡 Binance  │               │           │           │
-│         │   ✅ Response (0.3s - mock) │           │           │
-│         │             │               │           │           │
-│         └─────────────┼───────────────┼───────────┘           │
-│                       │               │                       │
-│                   Wait for all...     │                       │
-│                                      │                       │
-│                               🧮 Aggregate (1.2s total)      │
-│                                                               │
-│  📈 Performance Gain:                                         │
-│     Sequential: 1.2s + 0.8s + 0.3s = 2.3s                   │
-│     Parallel:   max(1.2s, 0.8s, 0.3s) = 1.2s               │
-│     Improvement: ~48% faster! 🚀                             │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 🧮 Aggregation Algorithm Detail
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                  🔬 DATA AGGREGATION LOGIC                     │
-│                                                                 │
-│  def aggregate_market_data(results):                           │
-│      │                                                         │
-│      ├── 📊 Input Data:                                        │
-│      │   ┌─────────────────────────────────────────────────┐   │
-│      │   │ coinbase:    {"BTC": 63500, "ETH": 4150}       │   │
-│      │   │ cryptocomp:  {"BTC": 63450, "ETH": 4160}       │   │
-│      │   │ binance:     {"BTC": 63600, "ETH": 4140}       │   │
-│      │   └─────────────────────────────────────────────────┘   │
-│      │                                                         │
-│      ├── 🧮 Price Calculation:                                 │
-│      │   ┌─────────────────────────────────────────────────┐   │
-│      │   │ BTC_prices = [63500, 63450, 63600]             │   │
-│      │   │ BTC_avg = 63516.67                              │   │
-│      │   │ BTC_std = 75.83                                 │   │
-│      │   │ BTC_spread = (max-min)/avg = 0.24%              │   │
-│      │   └─────────────────────────────────────────────────┘   │
-│      │                                                         │
-│      ├── 🎯 Confidence Scoring:                                │
-│      │   ┌─────────────────────────────────────────────────┐   │
-│      │   │ confidence = 1 - (std_dev / mean)               │   │
-│      │   │ if spread < 0.5%: confidence += 0.1             │   │
-│      │   │ if sources >= 3: confidence += 0.05             │   │
-│      │   │ BTC_confidence = 0.94 (excellent!)              │   │
-│      │   └─────────────────────────────────────────────────┘   │
-│      │                                                         │
-│      └── 📈 Market Signals:                                    │
-│          ┌─────────────────────────────────────────────────┐   │
-│          │ spread_analysis:                                │   │
-│          │   "Low spread (0.24%) indicates healthy liq."  │   │
-│          │ volume_trend:                                   │   │
-│          │   "Combined volume: 4.1M USD"                   │   │
-│          │ price_divergence:                               │   │
-│          │   "Max deviation: 0.24% - Normal range"        │   │
-│          └─────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 🔄 Error Handling & Resilience
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    🛡️ RESILIENCE STRATEGY                      │
-│                                                                 │
-│  Scenario 1: One Provider Fails                               │
-│  ┌─────────────────────────────────────────────────────────┐   │
-│  │ 🏦 Coinbase: ✅ Success (BTC: $63500)                  │   │
-│  │ 📊 CryptoComp: ❌ Timeout/Error                        │   │
-│  │ 🟡 Binance: ✅ Success (BTC: $63600)                   │   │
-│  │                                                         │   │
-│  │ Result: Continue with 2 sources                        │   │
-│  │ Confidence: 0.89 (slightly reduced)                    │   │
-│  │ Note: "CryptoCompare unavailable"                      │   │
-│  └─────────────────────────────────────────────────────────┘   │
-│                                                                 │
-│  Scenario 2: Multiple Providers Fail                          │
-│  ┌─────────────────────────────────────────────────────────┐   │
-│  │ 🏦 Coinbase: ❌ API Limit                              │   │
-│  │ 📊 CryptoComp: ✅ Success (BTC: $63450)                │   │
-│  │ 🟡 Binance: ❌ Network Error                           │   │
-│  │                                                         │   │
-│  │ Result: Single source data                             │   │
-│  │ Confidence: 0.60 (low - warn user)                     │   │
-│  │ Note: "Limited data - consider waiting"                │   │
-│  └─────────────────────────────────────────────────────────┘   │
-│                                                                 │
-│  Scenario 3: All Providers Fail                               │
-│  ┌─────────────────────────────────────────────────────────┐   │
-│  │ 🏦 Coinbase: ❌ Maintenance                            │   │
-│  │ 📊 CryptoComp: ❌ API Down                             │   │
-│  │ 🟡 Binance: ❌ Rate Limit                              │   │
-│  │                                                         │   │
-│  │ Result: Graceful degradation                           │   │
-│  │ Message: "Market data temporarily unavailable"         │   │
-│  │ Fallback: Cached data (if available)                   │   │
-│  └─────────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 📊 JSON Output Schema
-
-```json
-{
-  "aggregated_data": {
-    "BTC_USD": {
-      "price": 63516.67,
-      "confidence": 0.94,
-      "sources_count": 3,
-      "last_updated": "2025-09-23T17:30:00Z"
-    },
-    "ETH_USD": {
-      "price": 4150.33,
-      "confidence": 0.91,
-      "sources_count": 3,
-      "last_updated": "2025-09-23T17:30:00Z"
-    }
-  },
-  "individual_sources": {
-    "coinbase": {
-      "BTC": {"price": 63500, "volume": "1.2M", "status": "online"},
-      "ETH": {"price": 4150, "volume": "25.6M", "status": "online"}
-    },
-    "cryptocompare": {
-      "BTC": {"price": 63450, "volume": "N/A", "status": "active"},
-      "ETH": {"price": 4160, "volume": "N/A", "status": "active"}
-    },
-    "binance": {
-      "BTC": {"price": 63600, "volume": "2.1M", "status": "mock"},
-      "ETH": {"price": 4140, "volume": "18.3M", "status": "mock"}
-    }
-  },
-  "market_signals": {
-    "spread_analysis": "Low spread (0.24%) indicates healthy liquidity",
-    "volume_trend": "Combined BTC volume: 3.3M USD (+12% from avg)",
-    "price_divergence": "Max deviation: 0.24% - Normal range",
-    "data_quality": "High - 3 sources, low variance",
-    "recommendation": "Data suitable for trading decisions"
-  },
-  "metadata": {
-    "query_time_ms": 1247,
-    "sources_queried": ["coinbase", "cryptocompare", "binance"],
-    "sources_successful": ["coinbase", "cryptocompare", "binance"],
-    "sources_failed": [],
-    "aggregation_method": "weighted_average",
-    "confidence_threshold": 0.75
-  }
-}
-```
-
----
-*Diagramma dettaglio asincrono: 2025-09-23*
-*Focus: Performance, Resilienza, Qualità Dati*
\ No newline at end of file
diff --git a/docs/Market_Data_Implementation_Plan.md b/docs/Market_Data_Implementation_Plan.md
deleted file mode 100644
index e494ca7..0000000
--- a/docs/Market_Data_Implementation_Plan.md
+++ /dev/null
@@ -1,96 +0,0 @@
-# 🚀 Piano di Implementazione - Market Data Enhancement
-
-## 📋 Roadmap Implementazioni
-
-### **Fase 1: Binance Mock Provider** 
-**Obiettivo**: Aggiungere terzo provider per test aggregazione
-- ✅ Creare `binance_signer.py` con mock data
-- ✅ Integrare nel MarketAgent
-- ✅ Testare detection automatica provider
-- **Deliverable**: 3 provider funzionanti (Coinbase, CryptoCompare, Binance)
-
-### **Fase 2: Interrogazione Condizionale**
-**Obiettivo**: Auto-detection credenziali e interrogazione intelligente
-- ✅ Migliorare detection chiavi API nel MarketAgent
-- ✅ Skip provider se credenziali mancanti (no errori)
-- ✅ Logging informativo per provider disponibili/non disponibili
-- ✅ Gestione graceful degradation
-- **Deliverable**: Sistema resiliente che funziona con qualsiasi combinazione di provider
-
-### **Fase 3: Interrogazione Asincrona + Aggregazione JSON**
-**Obiettivo**: Performance boost e formato dati professionale
-
-#### **3A. Implementazione Asincrona**
-- ✅ Refactor MarketAgent per supporto `async/await`
-- ✅ Chiamate parallele a tutti i provider disponibili
-- ✅ Timeout management per provider lenti
-- ✅ Error handling per provider che falliscono
-
-#### **3B. Aggregazione Dati Intelligente**
-- ✅ Calcolo `confidence` basato su concordanza prezzi
-- ✅ Analisi `spread` tra provider
-- ✅ Detection `price_divergence` per anomalie
-- ✅ Volume trend analysis
-- ✅ Formato JSON strutturato:
-
-```json
-{
-  "aggregated_data": {
-    "BTC_USD": {
-      "price": 43250.12,
-      "confidence": 0.95,
-      "sources_count": 4
-    }
-  },
-  "individual_sources": {
-    "coinbase": {"price": 43245.67, "volume": "1.2M"},
-    "binance": {"price": 43255.89, "volume": "2.1M"},
-    "cryptocompare": {"price": 43248.34, "volume": "0.8M"}
-  },
-  "market_signals": {
-    "spread_analysis": "Low spread (0.02%) indicates healthy liquidity",
-    "volume_trend": "Volume up 15% from 24h average", 
-    "price_divergence": "Max deviation: 0.05% - Normal range"
-  }
-}
-```
-
-**Deliverable**: Sistema asincrono con analisi avanzata dei dati di mercato
-
-## 🎯 Benefici Attesi
-
-### **Performance**
-- ⚡ Tempo risposta: da ~4s sequenziali a ~1s paralleli
-- 🔄 Resilienza: sistema funziona anche se 1-2 provider falliscono
-- 📊 Qualità dati: validazione incrociata tra provider
-
-### **Professionalità**
-- 📈 Confidence scoring per decisioni informate
-- 🔍 Market signals per trading insights
-- 📋 Formato standardizzato per integrazioni future
-
-### **Scalabilità**
-- ➕ Facile aggiunta nuovi provider
-- 🔧 Configurazione flessibile via environment
-- 📝 Logging completo per debugging
-
-## 🧪 Test Strategy
-
-1. **Unit Tests**: Ogni provider singolarmente
-2. **Integration Tests**: Aggregazione multi-provider
-3. **Performance Tests**: Confronto sync vs async
-4. **Resilience Tests**: Fallimento provider singoli
-5. **E2E Tests**: Full workflow con UI Gradio
-
-## 📅 Timeline Stimata
-
-- **Fase 1**: ~1h (setup Binance mock)
-- **Fase 2**: ~1h (detection condizionale)  
-- **Fase 3**: ~2-3h (async + aggregazione)
-- **Testing**: ~1h (validation completa)
-
-**Total**: ~5-6h di lavoro strutturato
-
----
-*Documento creato: 2025-09-23*
-*Versione: 1.0*
\ No newline at end of file
diff --git a/docs/Piano di Sviluppo.md b/docs/Piano di Sviluppo.md
deleted file mode 100644
index c4b1a51..0000000
--- a/docs/Piano di Sviluppo.md	
+++ /dev/null
@@ -1,73 +0,0 @@
-# Guida alla Realizzazione del Progetto
-
-Questa guida è una lista di controllo per l'implementazione del tuo progetto. È divisa in fasi logiche, ognuna con i compiti specifici da svolgere.
-
-## Fase 1: Preparazione e Architettura di Base
-
-### Impostazione dell'ambiente
-
-* Scegliere il linguaggio di programmazione (es. **Python**).
-* Utilizzare la libreria `agno` per la creazione di agenti e **LangChain/LlamaIndex** per la gestione dell'LLM e dell'orchestrazione.
-
-### Definizione dell'Architettura degli agenti
-
-* Definire la classe base per gli agenti, con metodi comuni come `execute()` e `reason()`.
-* Delineare i ruoli e le interfacce di tutti gli agenti (`RicercatoreDati`, `AnalistaSentiment`, `MotorePredittivo`, `Orchestratore`), stabilendo come comunicheranno tra loro.
-
----
-
-## Fase 2: Implementazione degli Agenti Core
-
-### Agente `RicercatoreDati`
-
-* Implementare la logica per connettersi a un'API di exchange (es. **Binance, Coindesk, CoinMarketCap**).
-* Testare la capacità di recuperare dati in tempo reale per diverse criptovalute (prezzo, volume, capitalizzazione) e **assicurarsi che la gestione degli errori sia robusta**.
-
-### Agente `AnalistaSentiment`
-
-* **Agente `Social`:**
-  * Scegliere un metodo per lo scraping di forum e social media (es. **Reddit API, librerie per Twitter/X, BeautifulSoup per web scraping**).
-  * Implementare un modulo di analisi del testo per classificare il sentiment (positivo, negativo, neutro) utilizzando **modelli pre-addestrati (es. VADER) o fine-tuning di modelli più avanzati**.
-* **Agente `News`:**
-  * Ottenere una chiave API per un servizio di notizie (es. **NewsAPI**).
-  * Implementare la logica per cercare articoli pertinenti a una criptovaluta specifica o al mercato in generale, e **filtrare le notizie in base a parole chiave rilevanti**.
-
-### Agente `MotorePredittivo`
-
-* Definire la logica per integrare i dati numerici del `RicercatoreDati` con il sentiment dell'`AnalistaSentiment`.
-* Creare un **prompt avanzato** per l'LLM che lo guidi a generare previsioni e strategie. Dovrai usare tecniche come la **chain-of-thought** per rendere il ragionamento trasparente. Assicurarsi che il prompt includa vincoli specifici per lo stile di investimento (aggressivo/conservativo).
-
----
-
-## Fase 3: Costruzione dell'Orchestratore e Test di Integrazione
-
-### Implementazione dell'Agente Orchestratore
-
-* **Gestione dell'Input Utente:** Creare un metodo che riceve la richiesta dell'utente (es. `analizza_cripto('Bitcoin', 'aggressivo')`). Analizzare il tipo di richiesta e le preferenze utente.
-* **Recupero della Memoria Utente:** Integrare la logica per recuperare la cronologia delle richieste passate dal database e preparare i dati come contesto aggiuntivo per l'LLM.
-* **Orchestrazione e Flusso di Lavoro:** Chiamare gli agenti (`RicercatoreDati`, `AnalistaSentiment`) e passare i risultati combinati all'**Agente `MotorePredittivo`** per generare previsioni e strategie.
-* **Valutazione e Selezione Strategica:** Ricevere le previsioni dal `MotorePredittivo` e applicare le regole di valutazione basate sulle preferenze dell'utente per selezionare le strategie più appropriate.
-* **Presentazione e Persistenza:** Costruire il report finale e salvare la sessione completa nel database.
-
----
-
-## Fase 4: Gestione della Persistenza e dell'Interfaccia Utente
-
-* **Database per la persistenza:** Scegli un database (es. **Firestore, MongoDB, PostgreSQL**) per salvare la cronologia delle richieste degli utenti. Implementa la logica per salvare e recuperare le sessioni di consulenza passate, associandole a un ID utente, e **struttura i dati per una ricerca efficiente**.
-
-* **Interfaccia utente (UI):** Costruisci un'interfaccia utente semplice e intuitiva che permetta di inserire i parametri di richiesta. Aggiungi una sezione per visualizzare i risultati, inclusi i grafici e le note che spiegano il ragionamento dell'agente.
-
----
-
-## Fase 5: Test del Sistema
-
-* **Test unitari:** Esegui test su ogni agente singolarmente per assicurarti che funzioni correttamente (es. l'agente `RicercatoreDati` recupera i dati, l'agente `AnalistaSentiment` classifica correttamente un testo). **Crea dei mock per le API esterne per testare la logica interna senza dipendenze esterne**.
-* **Test di integrazione:** Esegui scenari di test completi per l'intero sistema. Verifica che l'orchestrazione tra gli agenti avvenga senza intoppi e che i dati vengano passati correttamente tra di essi.
-
----
-
-## Fase 6: Valutazione dei Risultati
-
-* **Valutazione della qualità:** Verifica la qualità delle raccomandazioni generate. L'output è logico e ben argomentato?
-* **Trasparenza del ragionamento:** Controlla che le note (`Ragionamenti`) siano chiare e forniscano un'effettiva trasparenza del processo decisionale dell'agente.
-* **Confronto e validazione:** Confronta le raccomandazioni con dati storici e scenari ipotetici per valutarne la plausibilità.
\ No newline at end of file
-- 
2.49.1


From b33389c4b6ef8232f5314d5f2e19ba184bc6b807 Mon Sep 17 00:00:00 2001
From: Berack96 <giacomobertolazzi7@gmail.com>
Date: Wed, 22 Oct 2025 09:17:09 +0200
Subject: [PATCH 3/6] Aggiornata la documentazione dell'architettura dell'app

---
 docs/App_Architecture_Diagrams.md | 802 ++++++++++++++++++++++--------
 1 file changed, 592 insertions(+), 210 deletions(-)

diff --git a/docs/App_Architecture_Diagrams.md b/docs/App_Architecture_Diagrams.md
index a498770..792d05c 100644
--- a/docs/App_Architecture_Diagrams.md
+++ b/docs/App_Architecture_Diagrams.md
@@ -4,37 +4,82 @@
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│                        🌐 GRADIO UI                              │
-│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
-│  │   User Input    │  │    Provider     │  │     Style       │  │
-│  │   (Query)       │  │   (Model)       │  │  (Conservative/ │  │
-│  │                 │  │                 │  │   Aggressive)   │  │
-│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
+│                   🌐 INTERFACCE UTENTE                          │
+│  ┌────────────────────────────────────────────────────────────┐ │
+│  │             💬 Gradio Web Interface                        │ │
+│  │  ┌──────────┐  ┌──────────┐  ┌───────────────────────┐   │ │
+│  │  │  Chat    │  │  Model   │  │  Strategy (Strategy)  │   │ │
+│  │  │ History  │  │Dropdown  │  │  - Conservative       │   │ │
+│  │  │          │  │          │  │  - Aggressive         │   │ │
+│  │  └──────────┘  └──────────┘  └───────────────────────┘   │ │
+│  └────────────────────────────────────────────────────────────┘ │
+│  ┌────────────────────────────────────────────────────────────┐ │
+│  │             📱 Telegram Bot Interface                      │ │
+│  │         (Mini App con integrazione Gradio)                 │ │
+│  └────────────────────────────────────────────────────────────┘ │
 └─────────────────────────┬───────────────────────────────────────┘
                           │
                           ▼
 ┌─────────────────────────────────────────────────────────────────┐
-│                    🔧 TOOL AGENT                                │
-│                  (Central Orchestrator)                        │
-│                                                                 │
-│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
-│  │ 1. Collect Data │  │ 2. Analyze      │  │ 3. Predict &    │ │
-│  │                 │  │   Sentiment     │  │   Recommend     │ │
-│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+│                    🎯 CHAT MANAGER                              │
+│               (Gestione Conversazioni)                          │
+│  ┌─────────────────────────────────────────────────────────┐   │
+│  │ - Mantiene storico messaggi (history)                   │   │
+│  │ - Gestisce input Pipeline (PipelineInputs)              │   │
+│  │ - Salva/Carica chat (JSON)                              │   │
+│  │ - Interfaccia Gradio (gradio_build_interface)           │   │
+│  └─────────────────────────────────────────────────────────┘   │
 └─────────────────────────┬───────────────────────────────────────┘
                           │
                           ▼
 ┌─────────────────────────────────────────────────────────────────┐
-│                   📊 AGENT ECOSYSTEM                           │
+│                    🔄 AGNO WORKFLOW PIPELINE                   │
+│                  (Orchestrazione Asincrona)                     │
 │                                                                 │
-│ ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ ┌───────────┐│
-│ │   MARKET    │  │    NEWS     │  │   SOCIAL    │ │ PREDICTOR ││
-│ │   AGENT     │  │   AGENT     │  │   AGENT     │ │  AGENT    ││
-│ │             │  │             │  │             │ │           ││
-│ │ 📈 Coinbase │  │ 📰 News API │  │ 🐦 Social  │ │ 🤖 LLM    ││
-│ │ 📊 CryptoCmp│  │             │  │    Media    │ │  Analysis ││
-│ │ 🟡 Binance  │  │             │  │             │ │           ││
-│ └─────────────┘  └─────────────┘  └─────────────┘ └───────────┘│
+│  Step 1: 🔍 Query Check         → Verifica query crypto        │
+│  Step 2: 🤔 Condition Check     → Valida se procedere          │
+│  Step 3: 📊 Info Recovery       → Team di raccolta dati        │
+│  Step 4: 📝 Report Generation   → Genera report finale         │
+│                                                                 │
+│  Pipeline Events: QUERY_CHECK | QUERY_ANALYZER |               │
+│                   INFO_RECOVERY | REPORT_GENERATION |          │
+│                   TOOL_USED | RUN_FINISHED                      │
+└─────────────────────────┬───────────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                   🤖 AGNO AGENT ECOSYSTEM                       │
+│                                                                 │
+│ ┌───────────────────────────────────────────────────────────┐  │
+│ │             👔 TEAM LEADER (Agno Team)                    │  │
+│ │  - Coordina Market, News, Social Agents                   │  │
+│ │  - Tools: ReasoningTools, PlanMemoryTool,                 │  │
+│ │           CryptoSymbolsTools                              │  │
+│ │  - Model: Configurabile (team_leader_model)               │  │
+│ └───────────────────────────────────────────────────────────┘  │
+│         │                      │                      │         │
+│         ▼                      ▼                      ▼         │
+│ ┌─────────────┐       ┌─────────────┐       ┌─────────────┐   │
+│ │   MARKET    │       │    NEWS     │       │   SOCIAL    │   │
+│ │   AGENT     │       │   AGENT     │       │   AGENT     │   │
+│ │  (Agno)     │       │  (Agno)     │       │  (Agno)     │   │
+│ │             │       │             │       │             │   │
+│ │ Tool:       │       │ Tool:       │       │ Tool:       │   │
+│ │ MarketAPIs  │       │ NewsAPIs    │       │ SocialAPIs  │   │
+│ │ Tool        │       │ Tool        │       │ Tool        │   │
+│ └─────────────┘       └─────────────┘       └─────────────┘   │
+│                                                                 │
+│ ┌───────────────────────────────────────────────────────────┐  │
+│ │           � QUERY CHECK AGENT (Agno Agent)              │  │
+│ │  - Valida se la query è relativa a crypto                │  │
+│ │  - Output Schema: QueryOutputs (is_crypto: bool)          │  │
+│ └───────────────────────────────────────────────────────────┘  │
+│                                                                 │
+│ ┌───────────────────────────────────────────────────────────┐  │
+│ │        📋 REPORT GENERATOR AGENT (Agno Agent)            │  │
+│ │  - Genera report finale basato su dati raccolti           │  │
+│ │  - Applica strategia (Conservative/Aggressive)            │  │
+│ └───────────────────────────────────────────────────────────┘  │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
@@ -45,211 +90,548 @@
     │
     │ "Analizza Bitcoin con strategia aggressiva"
     ▼
-┌─────────────────────────────────────────────────────────────┐
-│                🔧 TOOL AGENT                               │
-│                                                             │
-│  def interact(query, provider, style):                     │
-│      │                                                     │
-│      ├── 📊 market_data = market_agent.analyze(query)      │
-│      ├── 📰 news_sentiment = news_agent.analyze(query)     │
-│      ├── 🐦 social_sentiment = social_agent.analyze(query) │
-│      │                                                     │
-│      └── 🤖 prediction = predictor_agent.predict(...)      │
-└─────────────────────────────────────────────────────────────┘
-    │
-    ▼
-📊 MARKET AGENT - Parallel Data Collection
-┌─────────────────────────────────────────────────────────────┐
-│                                                             │
-│  🔍 Auto-detect Available Providers:                       │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
-│  │  Coinbase   │  │ CryptoComp  │  │   Binance   │        │
-│  │    REST     │  │     API     │  │    Mock     │        │
-│  │             │  │             │  │             │        │
-│  │ ✅ Active   │  │ ✅ Active   │  │ ✅ Active   │        │
-│  │ $63,500 BTC │  │ $63,450 BTC │  │ $63,600 BTC │        │
-│  └─────────────┘  └─────────────┘  └─────────────┘        │
-│                                                             │
-│  📈 Aggregated Result:                                     │
-│  {                                                          │
-│    "aggregated_data": {                                     │
-│      "BTC_USD": {                                          │
-│        "price": 63516.67,                                  │
-│        "confidence": 0.94,                                 │
-│        "sources_count": 3                                  │
-│      }                                                     │
-│    },                                                      │
-│    "individual_sources": {...},                           │
-│    "market_signals": {...}                                │
-│  }                                                         │
-└─────────────────────────────────────────────────────────────┘
-    │
-    ▼
-📰 NEWS AGENT + 🐦 SOCIAL AGENT
-┌─────────────────────────────────────────────────────────────┐
-│                                                             │
-│  📰 News Sentiment: "Positive momentum, institutional      │
-│      adoption increasing..."                               │
-│                                                             │
-│  🐦 Social Sentiment: "Bullish sentiment on Reddit,       │
-│      Twitter mentions up 15%..."                          │
-└─────────────────────────────────────────────────────────────┘
-    │
-    ▼
-🤖 PREDICTOR AGENT
-┌─────────────────────────────────────────────────────────────┐
-│                                                             │
-│  Input:                                                     │
-│  ├── 📊 Market Data (aggregated + confidence)              │
-│  ├── 📰🐦 Combined Sentiment                               │
-│  ├── 🎯 Style: "aggressive"                                │
-│  └── 🤖 Provider: "openai/anthropic/google..."             │
-│                                                             │
-│  🧠 LLM Processing:                                         │
-│  "Based on high confidence market data (0.94) showing     │
-│   $63,516 BTC with positive sentiment across news and     │
-│   social channels, aggressive strategy recommendation..."   │
-└─────────────────────────────────────────────────────────────┘
-    │
-    ▼
-📋 FINAL OUTPUT
-┌─────────────────────────────────────────────────────────────┐
-│  📊 Market Data Summary                                     │
-│  📰🐦 Sentiment Analysis                                   │
-│  📈 Final Recommendation:                                   │
-│      "Strong BUY signal with 85% confidence..."           │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## 🏛️ Architettura dei Provider (Market Agent)
-
-```
 ┌─────────────────────────────────────────────────────────────────┐
-│                    📊 MARKET AGENT                             │
-│                                                                 │
-│  🔍 Provider Detection Logic:                                   │
-│  ┌─────────────────────────────────────────────────────────────┐│
-│  │ def _setup_providers():                                     ││
-│  │   ├── 🔑 Check CDP_API_KEY_NAME + CDP_API_PRIVATE_KEY      ││
-│  │   │   └── ✅ Setup Coinbase Advanced Trade                 ││
-│  │   ├── 🔑 Check CRYPTOCOMPARE_API_KEY                       ││
-│  │   │   └── ✅ Setup CryptoCompare                           ││
-│  │   └── 🔑 Check BINANCE_API_KEY (future)                    ││
-│  │       └── ✅ Setup Binance API                             ││
-│  └─────────────────────────────────────────────────────────────┘│
-│                                                                 │
-│  📡 Data Flow:                                                  │
-│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐        │
-│  │  Provider 1 │───▶│             │◀───│  Provider 2 │        │
-│  │  Coinbase   │    │  AGGREGATOR │    │ CryptoComp  │        │
-│  │             │    │             │    │             │        │
-│  │ Real-time   │    │ ┌─────────┐ │    │ Real-time   │        │
-│  │ Market Data │    │ │Confidence│ │    │ Market Data │        │
-│  └─────────────┘    │ │Scoring  │ │    └─────────────┘        │
-│                     │ │         │ │                           │
-│  ┌─────────────┐    │ │ Spread  │ │    ┌─────────────┐        │
-│  │  Provider 3 │───▶│ │Analysis │ │◀───│  Provider N │        │
-│  │  Binance    │    │ │         │ │    │   Future    │        │
-│  │             │    │ └─────────┘ │    │             │        │
-│  │ Mock Data   │    │             │    │             │        │
-│  └─────────────┘    └─────────────┘    └─────────────┘        │
+│                   � CHAT MANAGER                               │
+│                                                                  │
+│  - Riceve messaggio utente                                      │
+│  - Gestisce history della conversazione                         │
+│  - Prepara PipelineInputs con:                                  │
+│    * user_query: "Analizza Bitcoin..."                          │
+│    * strategy: "aggressive"                                     │
+│    * models: team_leader_model, team_model, etc.                │
+└─────────────────────────────────────────────────────────────────┘
+    │
+    ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              🔄 AGNO WORKFLOW PIPELINE                          │
+│                                                                  │
+│  Run ID: [3845] Pipeline query: "Analizza Bitcoin..."          │
+│                                                                  │
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │ STEP 1: 🔍 QUERY CHECK (Query Check Agent)              │  │
+│  │                                                          │  │
+│  │  Input: QueryInputs(user_query, strategy)               │  │
+│  │  Agent: query_analyzer_model (Agno Agent)               │  │
+│  │  Output: QueryOutputs(response, is_crypto: bool)        │  │
+│  │                                                          │  │
+│  │  Result: {"is_crypto": true, "response": "..."}         │  │
+│  │  Event: QUERY_CHECK completed                           │  │
+│  └──────────────────────────────────────────────────────────┘  │
+    │
+    ▼
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │ STEP 2: 🤔 CONDITION CHECK                               │  │
+│  │                                                          │  │
+│  │  Valida: previous_step_content.is_crypto                │  │
+│  │  If False → StopOutput(stop=True)                       │  │
+│  │  If True  → Continua al prossimo step                   │  │
+│  └──────────────────────────────────────────────────────────┘  │
+    │
+    ▼
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │ STEP 3: 📊 INFO RECOVERY (Team)                         │  │
+│  │                                                          │  │
+│  │  👔 Team Leader coordina:                               │  │
+│  │     ├── 📈 Market Agent → MarketAPIsTool                │  │
+│  │     ├── 📰 News Agent   → NewsAPIsTool                  │  │
+│  │     └── 🐦 Social Agent → SocialAPIsTool                │  │
+│  │                                                          │  │
+│  │  Tools disponibili al Team Leader:                      │  │
+│  │     - ReasoningTools (ragionamento)                     │  │
+│  │     - PlanMemoryTool (memoria del piano)                │  │
+│  │     - CryptoSymbolsTools (simboli crypto)               │  │
+│  │                                                          │  │
+│  │  Events: TOOL_USED per ogni chiamata tool               │  │
+│  │  Event: INFO_RECOVERY completed                         │  │
+│  └──────────────────────────────────────────────────────────┘  │
+    │
+    ▼
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │ STEP 4: 📝 REPORT GENERATION (Report Generator Agent)   │  │
+│  │                                                          │  │
+│  │  Input: Tutti i dati raccolti da Info Recovery          │  │
+│  │  Agent: report_generation_model (Agno Agent)            │  │
+│  │  Strategia: Applicata dal prompt (aggressive)           │  │
+│  │                                                          │  │
+│  │  Output: Report finale con raccomandazioni              │  │
+│  │  Event: REPORT_GENERATION completed                     │  │
+│  └──────────────────────────────────────────────────────────┘  │
+    │
+    ▼
+│  Event: RUN_FINISHED                                            │
+│  Return: Final report string (rimozione tag <think>)            │
+└─────────────────────────────────────────────────────────────────┘
+    │
+    ▼
+📋 FINAL OUTPUT TO USER
+┌─────────────────────────────────────────────────────────────────┐
+│  📊 Analisi Bitcoin (BTC)                                       │
+│                                                                  │
+│  � Dati di Mercato:                                            │
+│     - Prezzo: $63,516 (aggregato da 4 fonti)                   │
+│     - Volume 24h: $2.1M                                         │
+│     - Confidence: 94%                                           │
+│                                                                  │
+│  📰 Sentiment News: Positivo (istituzionale in crescita)       │
+│  🐦 Sentiment Social: Bullish (Reddit/Twitter +15%)            │
+│                                                                  │
+│  🎯 Raccomandazione (Strategia Aggressiva):                    │
+│     STRONG BUY - Allocazione 15-20% del portfolio              │
+│                                                                  │
+│  💭 Ragionamento: [dettagli dell'analisi...]                   │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-## 🔧 Signers Architecture
+## 🏛️ Architettura API e Tools
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│                     🔐 SIGNERS ECOSYSTEM                       │
+│                  � API TOOLS ARCHITECTURE                      │
+│                  (Agno Toolkit Integration)                     │
 │                                                                 │
-│  📁 src/app/signers/market_signers/                            │
-│  │                                                             │
-│  ├── 🏦 coinbase_rest_signer.py                                │
-│  │   ├── 🔑 Uses: CDP_API_KEY_NAME + CDP_API_PRIVATE_KEY      │
-│  │   ├── 📡 RESTClient from coinbase.rest                     │
-│  │   ├── 📊 get_asset_info() → Real Coinbase data            │
-│  │   └── 📈 get_multiple_assets() → Bulk data                 │
-│  │                                                             │
-│  ├── 📊 cryptocompare_signer.py                               │
-│  │   ├── 🔑 Uses: CRYPTOCOMPARE_API_KEY                       │
-│  │   ├── 📡 Direct HTTP requests                              │
-│  │   ├── 💰 get_crypto_prices() → Multi-currency             │
-│  │   └── 🏆 get_top_cryptocurrencies() → Market cap         │
-│  │                                                             │
-│  └── 🟡 binance_signer.py                                     │
-│      ├── 🔑 Uses: BINANCE_API_KEY (future)                    │
-│      ├── 📡 Mock implementation                               │
-│      ├── 🎭 Simulated market data                            │
-│      └── 📈 Compatible interface                              │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │         📊 MarketAPIsTool (Agno Toolkit)              │    │
+│  │                                                        │    │
+│  │  Tools disponibili:                                    │    │
+│  │  - get_product(asset_id)                              │    │
+│  │  - get_products(asset_ids)                            │    │
+│  │  - get_historical_prices(asset_id, limit)             │    │
+│  │  - get_products_aggregated(asset_ids)                 │    │
+│  │  - get_historical_prices_aggregated(asset_id, limit)  │    │
+│  │                                                        │    │
+│  │  🔄 WrapperHandler gestisce:                          │    │
+│  │  ┌──────────────┐  ┌──────────────┐                   │    │
+│  │  │  Binance     │  │  YFinance    │                   │    │
+│  │  │  Wrapper     │  │  Wrapper     │                   │    │
+│  │  └──────────────┘  └──────────────┘                   │    │
+│  │  ┌──────────────┐  ┌──────────────┐                   │    │
+│  │  │  CoinBase    │  │CryptoCompare │                   │    │
+│  │  │  Wrapper     │  │  Wrapper     │                   │    │
+│  │  └──────────────┘  └──────────────┘                   │    │
+│  │                                                        │    │
+│  │  Retry Logic: 3 tentativi per wrapper, 2s delay       │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │         📰 NewsAPIsTool (Agno Toolkit)                │    │
+│  │                                                        │    │
+│  │  🔄 WrapperHandler gestisce:                          │    │
+│  │  - NewsAPI Wrapper                                     │    │
+│  │  - GoogleNews Wrapper                                  │    │
+│  │  - DuckDuckGo Wrapper                                  │    │
+│  │  - CryptoPanic Wrapper                                 │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │         🐦 SocialAPIsTool (Agno Toolkit)              │    │
+│  │                                                        │    │
+│  │  🔄 WrapperHandler gestisce:                          │    │
+│  │  - Reddit Wrapper                                      │    │
+│  │  - X (Twitter) Wrapper                                 │    │
+│  │  - 4chan Wrapper                                       │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │         🔣 CryptoSymbolsTools (Agno Toolkit)          │    │
+│  │  - Gestisce simboli e nomi delle criptovalute          │    │
+│  │  - Carica da resources/cryptos.csv                     │    │
+│  └────────────────────────────────────────────────────────┘    │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-## 🚀 Future Enhancement: Async Flow
+## � WrapperHandler Pattern
 
 ```
-                    📱 USER REQUEST
-                          │
-                          ▼
-                 🔧 TOOL AGENT (async)
-                          │
-         ┌────────────────┼────────────────┐
-         │                │                │
-         ▼                ▼                ▼
-    📊 Market         📰 News          🐦 Social
-    Agent (async)     Agent (async)    Agent (async)
-         │                │                │
-    ┌────┼────┐           │                │
-    ▼    ▼    ▼           │                │
- Coinbase │ Binance       │                │
-    CC    │               │                │
-         ▼▼▼              ▼                ▼
-    🔄 Parallel      📰 Sentiment     🐦 Sentiment
-    Aggregation      Analysis         Analysis
-         │                │                │
-         └────────────────┼────────────────┘
-                          ▼
-                  🤖 PREDICTOR AGENT
-                     (LLM Analysis)
-                          │
-                          ▼
-                    📋 FINAL RESULT
-                  (JSON + Confidence)
+┌─────────────────────────────────────────────────────────────────┐
+│                    � WRAPPER HANDLER                           │
+│              (Resilient API Call Management)                    │
+│                                                                 │
+│  Input: List[WrapperType]                                      │
+│         try_per_wrapper: int = 3                               │
+│         retry_delay: int = 2                                   │
+│                                                                 │
+│  ┌───────────────────────────────────────────────────────────┐ │
+│  │ def try_call(func: Callable) -> OutputType:              │ │
+│  │                                                           │ │
+│  │   for wrapper in wrappers:                               │ │
+│  │     for attempt in range(try_per_wrapper):               │ │
+│  │       try:                                               │ │
+│  │         result = func(wrapper)                           │ │
+│  │         return result  # ✅ Success                      │ │
+│  │       except Exception as e:                             │ │
+│  │         log_error(e)                                     │ │
+│  │         sleep(retry_delay)                               │ │
+│  │         continue  # � Retry                             │ │
+│  │                                                           │ │
+│  │     # Switch to next wrapper                             │ │
+│  │                                                           │ │
+│  │   raise Exception("All wrappers failed")  # ❌ All fail  │ │
+│  └───────────────────────────────────────────────────────────┘ │
+│                                                                 │
+│  Esempio Flusso:                                               │
+│  ┌─────────┐  Fail   ┌─────────┐  Fail   ┌─────────┐         │
+│  │Binance  │────────▶│YFinance │────────▶│CoinBase │  ✅     │
+│  │(3 tries)│         │(3 tries)│         │(Success)│         │
+│  └─────────┘         └─────────┘         └─────────┘         │
+│                                                                 │
+│  Features:                                                     │
+│  ✅ Automatic failover tra providers                           │
+│  ✅ Retry logic configurabile                                  │
+│  ✅ Logging dettagliato degli errori                           │
+│  ✅ Type-safe con Generics                                     │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
-## 📊 Data Flow Example
+## � Data Aggregation Architecture
 
 ```
-Input: "Analyze Bitcoin aggressive strategy"
-│
-├── 📊 Market Agent Output:
-│   {
-│     "aggregated_data": {
-│       "BTC_USD": {"price": 63516.67, "confidence": 0.94}
-│     },
-│     "individual_sources": {
-│       "coinbase": {"price": 63500, "volume": "1.2M"},
-│       "cryptocompare": {"price": 63450, "volume": "N/A"},
-│       "binance": {"price": 63600, "volume": "2.1M"}
-│     },
-│     "market_signals": {
-│       "spread_analysis": "Low spread (0.24%) - healthy liquidity",
-│       "price_divergence": "Max deviation: 0.24% - Normal range"
-│     }
-│   }
-│
-├── 📰 News Sentiment: "Positive institutional adoption news..."
-├── 🐦 Social Sentiment: "Bullish Reddit sentiment, +15% mentions"
-│
-└── 🤖 Predictor Output:
-    "📈 Strong BUY recommendation based on:
-     - High confidence market data (94%)
-     - Positive news sentiment
-     - Bullish social indicators
-     - Low spread indicates healthy liquidity
-     
-     Aggressive Strategy: Consider 15-20% portfolio allocation"
+┌─────────────────────────────────────────────────────────────────┐
+│              📊 PRODUCT INFO AGGREGATION                        │
+│                                                                 │
+│  Input: dict[provider_name, list[ProductInfo]]                 │
+│                                                                 │
+│  Provider A: BTC → {price: 63500, volume: 1.2M}                │
+│  Provider B: BTC → {price: 63450, volume: N/A}                 │
+│  Provider C: BTC → {price: 63600, volume: 2.1M}                │
+│  Provider D: BTC → {price: 63550, volume: 1.8M}                │
+│                                                                 │
+│  ┌───────────────────────────────────────────────────────────┐ │
+│  │ Aggregation Logic:                                        │ │
+│  │                                                           │ │
+│  │ 1. Group by symbol (BTC, ETH, etc.)                      │ │
+│  │                                                           │ │
+│  │ 2. Aggregate Volume:                                     │ │
+│  │    avg_volume = sum(volumes) / count(providers)          │ │
+│  │                                                           │ │
+│  │ 3. Aggregate Price (weighted by volume):                 │ │
+│  │    weighted_price = sum(price * volume) / sum(volume)    │ │
+│  │                                                           │ │
+│  │ 4. Calculate Confidence:                                 │ │
+│  │    - Based on price spread                               │ │
+│  │    - Number of sources                                   │ │
+│  │    - Volume consistency                                  │ │
+│  └───────────────────────────────────────────────────────────┘ │
+│                                                                 │
+│  Output: list[ProductInfo]                                     │
+│  {                                                              │
+│    "id": "BTC_AGGREGATED",                                     │
+│    "symbol": "BTC",                                            │
+│    "price": 63516.67,  # Weighted average                      │
+│    "volume_24h": 1.7M,  # Average volume                       │
+│    "currency": "USD",                                          │
+│    "confidence": 0.94  # High confidence (low spread)          │
+│  }                                                              │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│           📈 HISTORICAL PRICE AGGREGATION                       │
+│                                                                 │
+│  Input: dict[provider_name, list[Price]]                       │
+│                                                                 │
+│  ┌───────────────────────────────────────────────────────────┐ │
+│  │ Aggregation Logic:                                        │ │
+│  │                                                           │ │
+│  │ 1. Align by timestamp (YYYY-MM-DD HH:MM)                 │ │
+│  │                                                           │ │
+│  │ 2. For each timestamp, calculate mean of:                │ │
+│  │    - high                                                 │ │
+│  │    - low                                                  │ │
+│  │    - open                                                 │ │
+│  │    - close                                                │ │
+│  │    - volume                                               │ │
+│  │                                                           │ │
+│  │ 3. Handle missing data gracefully                        │ │
+│  └───────────────────────────────────────────────────────────┘ │
+│                                                                 │
+│  Output: list[Price] (aggregated by timestamp)                 │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
+## 🎯 Configuration Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                  ⚙️ APP CONFIG (configs.yaml)                   │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │  port: 7860  # Gradio server port                     │    │
+│  │  gradio_share: false  # Public sharing                │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │  models:  # LLM Models Configuration                  │    │
+│  │    - label: "Qwen 3 (4B)"                             │    │
+│  │      provider: "ollama"                               │    │
+│  │      model_id: "qwen3:4b"                             │    │
+│  │    - label: "Qwen 3 (1.7B)"                           │    │
+│  │      provider: "ollama"                               │    │
+│  │      model_id: "qwen3:1.7b"                           │    │
+│  │    - label: "GPT-4 Turbo"                             │    │
+│  │      provider: "openai"                               │    │
+│  │      model_id: "gpt-4-turbo"                          │    │
+│  │      api_key_env: "OPENAI_API_KEY"                    │    │
+│  │    # ... altri modelli (Anthropic, Google, etc.)      │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │  strategies:  # Investment Strategies                 │    │
+│  │    - label: "Conservative"                            │    │
+│  │      description: "Low risk, stable returns..."       │    │
+│  │    - label: "Aggressive"                              │    │
+│  │      description: "High risk, high potential..."      │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │  agents:  # Agent-specific configurations             │    │
+│  │    team_model: "qwen3:4b"                             │    │
+│  │    team_leader_model: "qwen3:4b"                      │    │
+│  │    query_analyzer_model: "qwen3:1.7b"                 │    │
+│  │    report_generation_model: "qwen3:4b"                │    │
+│  │    strategy: "Conservative"                           │    │
+│  └────────────────────────────────────────────────────────┘    │
+│                                                                 │
+│  ┌────────────────────────────────────────────────────────┐    │
+│  │  api:  # API Configuration                            │    │
+│  │    retry_attempts: 3                                  │    │
+│  │    retry_delay_seconds: 2                             │    │
+│  └────────────────────────────────────────────────────────┘    │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│              🔐 ENVIRONMENT VARIABLES (.env)                    │
+│                                                                 │
+│  # Market APIs                                                 │
+│  CDP_API_KEY_NAME=...          # Coinbase                      │
+│  CDP_API_PRIVATE_KEY=...       # Coinbase                      │
+│  CRYPTOCOMPARE_API_KEY=...     # CryptoCompare                 │
+│  BINANCE_API_KEY=...           # Binance (future)              │
+│                                                                 │
+│  # News APIs                                                   │
+│  NEWS_API_KEY=...              # NewsAPI                       │
+│  CRYPTOPANIC_API_KEY=...       # CryptoPanic                   │
+│                                                                 │
+│  # Social APIs                                                 │
+│  REDDIT_CLIENT_ID=...          # Reddit                        │
+│  REDDIT_CLIENT_SECRET=...      # Reddit                        │
+│  X_BEARER_TOKEN=...            # Twitter/X                     │
+│                                                                 │
+│  # LLM Providers                                               │
+│  OPENAI_API_KEY=...            # OpenAI                        │
+│  ANTHROPIC_API_KEY=...         # Anthropic                     │
+│  GOOGLE_API_KEY=...            # Google                        │
+│                                                                 │
+│  # Telegram Bot                                                │
+│  TELEGRAM_BOT_TOKEN=...        # Telegram Bot                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 🗂️ Struttura del Progetto
+
+```
+upo-appAI/
+│
+├── 📁 src/app/                      # Codice principale
+│   ├── __main__.py                  # Entry point (Gradio + Telegram)
+│   ├── configs.py                   # Gestione configurazioni
+│   │
+│   ├── 📁 agents/                   # Sistema di agenti Agno
+│   │   ├── core.py                  # PipelineInputs, QueryInputs/Outputs
+│   │   ├── pipeline.py              # Workflow Pipeline con Agno
+│   │   ├── plan_memory_tool.py      # Tool per memoria del piano
+│   │   └── 📁 prompts/              # Prompt per gli agenti
+│   │       ├── query_check.txt      # Prompt Query Checker
+│   │       ├── team_leader.txt      # Prompt Team Leader
+│   │       ├── team_market.txt      # Prompt Market Agent
+│   │       ├── team_news.txt        # Prompt News Agent
+│   │       ├── team_social.txt      # Prompt Social Agent
+│   │       └── report_generation.txt # Prompt Report Generator
+│   │
+│   ├── 📁 api/                      # Layer API e Wrappers
+│   │   ├── wrapper_handler.py       # Pattern WrapperHandler generico
+│   │   │
+│   │   ├── 📁 core/                 # Interfacce base e modelli
+│   │   │   ├── markets.py           # MarketWrapper, ProductInfo, Price
+│   │   │   ├── news.py              # NewsWrapper, NewsItem
+│   │   │   └── social.py            # SocialWrapper, SocialPost
+│   │   │
+│   │   ├── 📁 markets/              # Implementazioni Market API
+│   │   │   ├── binance.py           # BinanceWrapper
+│   │   │   ├── coinbase.py          # CoinBaseWrapper
+│   │   │   ├── cryptocompare.py     # CryptoCompareWrapper
+│   │   │   └── yfinance.py          # YFinanceWrapper
+│   │   │
+│   │   ├── 📁 news/                 # Implementazioni News API
+│   │   │   ├── newsapi.py           # NewsAPIWrapper
+│   │   │   ├── googlenews.py        # GoogleNewsWrapper
+│   │   │   ├── duckduckgo.py        # DuckDuckGoWrapper
+│   │   │   └── cryptopanic_api.py   # CryptoPanicWrapper
+│   │   │
+│   │   ├── 📁 social/               # Implementazioni Social API
+│   │   │   ├── reddit.py            # RedditWrapper
+│   │   │   ├── x.py                 # XWrapper (Twitter)
+│   │   │   └── chan.py              # 4ChanWrapper
+│   │   │
+│   │   └── 📁 tools/                # Agno Toolkits
+│   │       ├── market_tool.py       # MarketAPIsTool (Agno Toolkit)
+│   │       ├── news_tool.py         # NewsAPIsTool (Agno Toolkit)
+│   │       ├── social_tool.py       # SocialAPIsTool (Agno Toolkit)
+│   │       └── symbols_tool.py      # CryptoSymbolsTools (Agno Toolkit)
+│   │
+│   └── 📁 interface/                # Interfacce utente
+│       ├── chat.py                  # ChatManager (Gradio)
+│       └── telegram_app.py          # TelegramApp (Bot)
+│
+├── 📁 tests/                        # Test suite completa
+│   ├── conftest.py                  # Configurazione pytest
+│   ├── 📁 agents/                   # Test agenti
+│   ├── 📁 api/                      # Test API wrappers
+│   ├── 📁 tools/                    # Test tools
+│   └── 📁 utils/                    # Test utilities
+│
+├── 📁 demos/                        # Script di esempio
+│   ├── agno_agent.py                # Demo Agno Agent
+│   ├── agno_workflow.py             # Demo Agno Workflow
+│   ├── coinbase_demo.py             # Demo Coinbase API
+│   ├── cryptocompare_demo.py        # Demo CryptoCompare API
+│   └── market_providers_api_demo.py # Demo aggregazione provider
+│
+├── 📁 resources/                    # Risorse statiche
+│   └── cryptos.csv                  # Database simboli crypto
+│
+├── 📁 docs/                         # Documentazione
+│   ├── App_Architecture_Diagrams.md # Questo file
+│   └── Progetto Esame.md            # Specifiche progetto
+│
+├── configs.yaml                     # Configurazione app (modelli, strategie)
+├── .env                             # Variabili d'ambiente (API keys)
+├── .env.example                     # Template per .env
+├── pyproject.toml                   # Dipendenze Python (uv/pip)
+├── Dockerfile                       # Container Docker
+├── docker-compose.yaml              # Orchestrazione Docker
+└── README.md                        # Documentazione principale
+```
+
+## 🔑 Componenti Chiave
+
+### 1. **Agno Framework Integration**
+L'applicazione utilizza il framework **Agno** per gestire:
+- **Agent**: Singoli agenti con modelli LLM specifici
+- **Team**: Coordinazione di più agenti sotto un Team Leader
+- **Workflow**: Pipeline asincrone con step condizionali
+- **Toolkit**: Integrazione tools con retry logic
+- **RunEvent**: Sistema di eventi per monitoraggio
+
+### 2. **WrapperHandler Pattern**
+Pattern generico per gestire multiple implementazioni API con:
+- Failover automatico tra provider
+- Retry logic configurabile
+- Type safety con Generics
+- Logging dettagliato
+
+### 3. **Data Aggregation**
+Sistema sofisticato di aggregazione che:
+- Combina dati da multiple fonti
+- Calcola confidence score
+- Gestisce dati mancanti/inconsistenti
+- Fornisce weighted averages
+
+### 4. **Multi-Interface Support**
+Due interfacce integrate:
+- **Gradio Web UI**: Chat interface con dropdown per modelli/strategie
+- **Telegram Bot**: Bot con Mini App integrato
+
+### 5. **Configuration Management**
+Sistema a due livelli:
+- **configs.yaml**: Configurazioni applicazione (modelli, strategie, agenti)
+- **.env**: Secrets e API keys (caricato con dotenv)
+
+## 🚀 Deployment Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    🐳 DOCKER DEPLOYMENT                         │
+│                                                                 │
+│  1. Load .env variables                                        │
+│  2. Build Docker image (Python 3.11)                           │
+│  3. Install dependencies (pyproject.toml)                      │
+│  4. Copy src/, configs.yaml, resources/                        │
+│  5. Expose port 7860 (Gradio)                                  │
+│  6. Run: python -m src.app                                     │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │  docker-compose up --build -d                            │  │
+│  │                                                          │  │
+│  │  Services:                                               │  │
+│  │  - app: Main application (Gradio + Telegram)            │  │
+│  │  - Networks: Bridge mode                                │  │
+│  │  - Volumes: .env mounted                                │  │
+│  └──────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                 💻 LOCAL DEVELOPMENT (UV)                       │
+│                                                                 │
+│  1. Install uv package manager                                 │
+│  2. uv venv (create virtual environment)                       │
+│  3. uv pip install -e . (editable install)                     │
+│  4. uv run src/app (run application)                           │
+│                                                                 │
+│  Benefits:                                                     │
+│  ✅ Fast dependency resolution                                 │
+│  ✅ Automatic PYTHONPATH setup                                 │
+│  ✅ Editable mode for development                              │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 🎯 Workflow Execution Model
+
+L'applicazione utilizza un modello di esecuzione **Asincrono** basato su Agno Workflow:
+
+```python
+# Pipeline di esecuzione
+async def interact_async():
+    workflow = Workflow(steps=[
+        query_check,         # Step 1: Verifica query
+        condition_query_ok,  # Step 2: Condizione
+        info_recovery,       # Step 3: Team di raccolta
+        report_generation    # Step 4: Report finale
+    ])
+    
+    # Esecuzione con streaming
+    iterator = await workflow.arun(
+        query,
+        stream=True,
+        stream_intermediate_steps=True
+    )
+    
+    # Event handling
+    async for event in iterator:
+        if event.event == PipelineEvent.TOOL_USED:
+            log(f"Tool: {event.tool.tool_name}")
+        elif event.event == WorkflowRunEvent.step_completed:
+            log(f"Step: {event.step_name} completed")
+```
+
+**Vantaggi:**
+- ⚡ Esecuzione asincrona per migliori performance
+- 📊 Streaming di eventi intermedi
+- 🎯 Gestione condizionale del flusso
+- 🔄 Retry automatico sui tools
+
+## 📈 Future Enhancements
+
+Possibili miglioramenti architetturali:
+
+1. **Parallel Tool Execution**: Esecuzione parallela di Market/News/Social agents
+2. **Caching Layer**: Redis/Memcached per ridurre chiamate API
+3. **Database Integration**: PostgreSQL per storico analisi
+4. **Real-time WebSocket**: Aggiornamenti live prezzi
+5. **ML Model Integration**: Modelli predittivi custom (LSTM, Transformer)
+6. **Advanced Aggregation**: Confidence scoring migliorato con ML
+7. **User Profiles**: Personalizzazione strategie per utente
+8. **Backtesting Module**: Validazione strategie su dati storici
+
 ---
-*Diagrammi creati: 2025-09-23*
-*Sistema: upo-appAI Market Analysis Platform*
\ No newline at end of file
+*Documento aggiornato: 2025-10-22*
+*Sistema: upo-appAI Crypto Analysis Platform*
+*Framework: Agno (Agentic AI) + Gradio + Telegram*
\ No newline at end of file
-- 
2.49.1


From 7015bdfdd06fc4e9a9e9987d62f7b53060fe0ffd Mon Sep 17 00:00:00 2001
From: Berack96 <giacomobertolazzi7@gmail.com>
Date: Wed, 22 Oct 2025 09:37:36 +0200
Subject: [PATCH 4/6] Aggiunti nuovi script demo per i provider di mercato e
 rimosso codice obsoleto

---
 demos/api_market_providers.py      |  12 +
 demos/api_news_providers.py        |  16 ++
 demos/api_socials_providers.py     |  17 ++
 demos/coinbase_demo.py             |  36 ---
 demos/cryptocompare_demo.py        |  36 ---
 demos/market_providers_api_demo.py | 348 -----------------------------
 demos/news_api.py                  |  18 --
 demos/ollama_demo.py               |  32 +--
 8 files changed, 53 insertions(+), 462 deletions(-)
 create mode 100644 demos/api_market_providers.py
 create mode 100644 demos/api_news_providers.py
 create mode 100644 demos/api_socials_providers.py
 delete mode 100644 demos/coinbase_demo.py
 delete mode 100644 demos/cryptocompare_demo.py
 delete mode 100644 demos/market_providers_api_demo.py
 delete mode 100644 demos/news_api.py

diff --git a/demos/api_market_providers.py b/demos/api_market_providers.py
new file mode 100644
index 0000000..a9ba754
--- /dev/null
+++ b/demos/api_market_providers.py
@@ -0,0 +1,12 @@
+from dotenv import load_dotenv
+from app.api.tools import MarketAPIsTool
+
+def main():
+    api = MarketAPIsTool()
+    prices_aggregated = api.get_historical_prices_aggregated("BTC", limit=5)
+    for price in prices_aggregated:
+        print(f"== [{price.timestamp}] {price.low:.2f} - {price.high:.2f} ==")
+
+if __name__ == "__main__":
+    load_dotenv()
+    main()
diff --git a/demos/api_news_providers.py b/demos/api_news_providers.py
new file mode 100644
index 0000000..4ac2f01
--- /dev/null
+++ b/demos/api_news_providers.py
@@ -0,0 +1,16 @@
+from dotenv import load_dotenv
+from app.api.tools import NewsAPIsTool
+
+def main():
+    api = NewsAPIsTool()
+    articles_aggregated = api.get_latest_news_aggregated(query="bitcoin", limit=2)
+    for provider, articles in articles_aggregated.items():
+        print("===================================")
+        print(f"Provider: {provider}")
+        for article in articles:
+            print(f"== [{article.time}] {article.title} ==")
+            print(f"   {article.description}")
+
+if __name__ == "__main__":
+    load_dotenv()
+    main()
diff --git a/demos/api_socials_providers.py b/demos/api_socials_providers.py
new file mode 100644
index 0000000..fb9da6e
--- /dev/null
+++ b/demos/api_socials_providers.py
@@ -0,0 +1,17 @@
+from dotenv import load_dotenv
+from app.api.tools import SocialAPIsTool
+
+def main():
+    api = SocialAPIsTool()
+    articles_aggregated = api.get_top_crypto_posts_aggregated(limit_per_wrapper=2)
+    for provider, posts in articles_aggregated.items():
+        print("===================================")
+        print(f"Provider: {provider}")
+        for post in posts:
+            print(f"== [{post.time}] - {post.title} ==")
+            print(f"   {post.description}")
+            print(f"   {len(post.comments)}")
+
+if __name__ == "__main__":
+    load_dotenv()
+    main()
diff --git a/demos/coinbase_demo.py b/demos/coinbase_demo.py
deleted file mode 100644
index 8b6bd41..0000000
--- a/demos/coinbase_demo.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#### FOR ALL FILES OUTSIDE src/ FOLDER ####
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
-###########################################
-
-from dotenv import load_dotenv
-from app.markets import CoinBaseWrapper
-
-def main():
-    print("Demo Coinbase CDP")
-
-    print("=== Chiavi API ===")
-    print(f"  COINBASE_API_KEY: {os.getenv('COINBASE_API_KEY') is not None}")
-    print(f"  COINBASE_API_SECRET: {os.getenv('COINBASE_API_SECRET') is not None}")
-
-    # Inizializza le API
-    coinbase = CoinBaseWrapper()
-
-    # ottenimento prezzo attuale
-    print("=== Demo prezzo attuale ===")
-    test_symbols = ["BTC", "ETH", "ADA"]
-    for symbol in test_symbols:
-        info = coinbase.get_product(symbol)
-        print(f"  {symbol}: ${info.price:,.2f}")
-
-    # ottenimento prezzi storici
-    print("\n=== Demo prezzi storici ===")
-    test_symbols = ["BTC", "ETH"]
-    for symbol in test_symbols:
-        prices = coinbase.get_historical_prices(symbol)
-        print(f"  {symbol}: {" ".join([f'${entry["price"]:,.2f}' for entry in prices[:5]])}") # mostra solo i primi 5
-
-if __name__ == "__main__":
-    load_dotenv()
-    main()
diff --git a/demos/cryptocompare_demo.py b/demos/cryptocompare_demo.py
deleted file mode 100644
index f929b87..0000000
--- a/demos/cryptocompare_demo.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#### FOR ALL FILES OUTSIDE src/ FOLDER ####
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
-###########################################
-
-from dotenv import load_dotenv
-from app.markets.cryptocompare import CryptoCompareWrapper
-
-def main():
-    print("Demo CryptoCompare")
-
-    print("=== Chiavi API ===")
-    print(f"  CRYPTOCOMPARE_API_KEY: {os.getenv('CRYPTOCOMPARE_API_KEY') is not None}")
-
-    # Inizializza le API
-    cryptocompare = CryptoCompareWrapper()
-
-    # ottenimento prezzo attuale
-    print("=== Demo prezzo attuale ===")
-    test_symbols = ["BTC", "ETH", "ADA"]
-    for symbol in test_symbols:
-        info = cryptocompare.get_product(symbol)
-        print(f"  {symbol}: ${info.price:,.2f}")
-
-    # ottenimento prezzi storici
-    print("=== Demo prezzi storici ===")
-    test_symbols = ["BTC", "ETH"]
-    for symbol in test_symbols:
-        prices = cryptocompare.get_historical_prices(symbol)
-        prices = [f'[${entry.high:,.2f}-${entry.low:,.2f}]' for entry in prices]
-        print(f"  {symbol}: {" ".join(prices[:5])}") # mostra solo i primi 5
-
-if __name__ == "__main__":
-    load_dotenv()
-    main()
\ No newline at end of file
diff --git a/demos/market_providers_api_demo.py b/demos/market_providers_api_demo.py
deleted file mode 100644
index c9ab116..0000000
--- a/demos/market_providers_api_demo.py
+++ /dev/null
@@ -1,348 +0,0 @@
-#!/usr/bin/env python3
-"""
-Demo Completo per Market Data Providers
-========================================
-
-Questo script dimostra l'utilizzo di tutti i wrapper che implementano BaseWrapper:
-- CoinBaseWrapper (richiede credenziali)
-- CryptoCompareWrapper (richiede API key)
-- BinanceWrapper (richiede credenziali)
-- PublicBinanceAgent (accesso pubblico)
-- YFinanceWrapper (accesso gratuito a dati azionari e crypto)
-
-Lo script effettua chiamate GET a diversi provider e visualizza i dati
-in modo strutturato con informazioni dettagliate su timestamp, stato
-delle richieste e formattazione tabellare.
-"""
-
-import sys
-import os
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-import traceback
-
-# Aggiungi il path src al PYTHONPATH
-project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root / "src"))
-
-from dotenv import load_dotenv
-from app.api.core.markets import MarketWrapper
-from app.api.markets import *
-
-# Carica variabili d'ambiente
-load_dotenv()
-
-class DemoFormatter:
-    """Classe per formattare l'output del demo in modo strutturato."""
-
-    @staticmethod
-    def print_header(title: str, char: str = "=", width: int = 80):
-        """Stampa un'intestazione formattata."""
-        print(f"\n{char * width}")
-        print(f"{title:^{width}}")
-        print(f"{char * width}")
-
-    @staticmethod
-    def print_subheader(title: str, char: str = "-", width: int = 60):
-        """Stampa una sotto-intestazione formattata."""
-        print(f"\n{char * width}")
-        print(f" {title}")
-        print(f"{char * width}")
-
-    @staticmethod
-    def print_request_info(provider_name: str, method: str, timestamp: datetime, 
-                          status: str, error: Optional[str] = None):
-        """Stampa informazioni sulla richiesta."""
-        print(f"🕒 Timestamp: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
-        print(f"🏷️  Provider: {provider_name}")
-        print(f"🔧 Method: {method}")
-        print(f"📊 Status: {status}")
-        if error:
-            print(f"❌ Error: {error}")
-        print()
-
-    @staticmethod
-    def print_product_table(products: List[Any], title: str = "Products"):
-        """Stampa una tabella di prodotti."""
-        if not products:
-            print(f"📋 {title}: Nessun prodotto trovato")
-            return
-
-        print(f"📋 {title} ({len(products)} items):")
-        print(f"{'Symbol':<15} {'ID':<20} {'Price':<12} {'Quote':<10} {'Status':<10}")
-        print("-" * 67)
-
-        for product in products[:10]:  # Mostra solo i primi 10
-            symbol = getattr(product, 'symbol', 'N/A')
-            product_id = getattr(product, 'id', 'N/A')
-            price = getattr(product, 'price', 0.0)
-            quote = getattr(product, 'quote_currency', 'N/A')
-            status = getattr(product, 'status', 'N/A')
-
-            # Tronca l'ID se troppo lungo
-            if len(product_id) > 18:
-                product_id = product_id[:15] + "..."
-
-            price_str = f"${price:.2f}" if price > 0 else "N/A"
-
-            print(f"{symbol:<15} {product_id:<20} {price_str:<12} {quote:<10} {status:<10}")
-
-        if len(products) > 10:
-            print(f"... e altri {len(products) - 10} prodotti")
-        print()
-
-    @staticmethod
-    def print_prices_table(prices: List[Any], title: str = "Historical Prices"):
-        """Stampa una tabella di prezzi storici."""
-        if not prices:
-            print(f"💰 {title}: Nessun prezzo trovato")
-            return
-
-        print(f"💰 {title} ({len(prices)} entries):")
-        print(f"{'Time':<12} {'Open':<12} {'High':<12} {'Low':<12} {'Close':<12} {'Volume':<15}")
-        print("-" * 75)
-
-        for price in prices[:5]:  # Mostra solo i primi 5
-            time_str = getattr(price, 'time', 'N/A')
-            # Il time è già una stringa, non serve strftime
-            if len(time_str) > 10:
-                time_str = time_str[:10]  # Tronca se troppo lungo
-
-            open_price = f"${getattr(price, 'open', 0):.2f}"
-            high_price = f"${getattr(price, 'high', 0):.2f}"
-            low_price = f"${getattr(price, 'low', 0):.2f}"
-            close_price = f"${getattr(price, 'close', 0):.2f}"
-            volume = f"{getattr(price, 'volume', 0):,.0f}"
-
-            print(f"{time_str:<12} {open_price:<12} {high_price:<12} {low_price:<12} {close_price:<12} {volume:<15}")
-
-        if len(prices) > 5:
-            print(f"... e altri {len(prices) - 5} prezzi")
-        print()
-
-class ProviderTester:
-    """Classe per testare i provider di market data."""
-
-    def __init__(self):
-        self.formatter = DemoFormatter()
-        self.test_symbols = ["BTC", "ETH", "ADA"]
-
-    def test_provider(self, wrapper: MarketWrapper, provider_name: str) -> Dict[str, Any]:
-        """Testa un provider specifico con tutti i metodi disponibili."""
-        results: Dict[str, Any] = {
-            "provider_name": provider_name,
-            "tests": {},
-            "overall_status": "SUCCESS"
-        }
-
-        self.formatter.print_subheader(f"🔍 Testing {provider_name}")
-
-        # Test get_product
-        for symbol in self.test_symbols:
-            timestamp = datetime.now()
-            try:
-                product = wrapper.get_product(symbol)
-                self.formatter.print_request_info(
-                    provider_name, f"get_product({symbol})", timestamp, "✅ SUCCESS"
-                )
-                if product:
-                    print(f"📦 Product: {product.symbol} (ID: {product.id})")
-                    print(f"   Price: ${product.price:.2f}, Quote: {product.currency}")
-                    print(f"   Volume 24h: {product.volume_24h:,.2f}")
-                else:
-                    print(f"📦 Product: Nessun prodotto trovato per {symbol}")
-
-                results["tests"][f"get_product_{symbol}"] = "SUCCESS"
-
-            except Exception as e:
-                error_msg = str(e)
-                self.formatter.print_request_info(
-                    provider_name, f"get_product({symbol})", timestamp, "❌ ERROR", error_msg
-                )
-                results["tests"][f"get_product_{symbol}"] = f"ERROR: {error_msg}"
-                results["overall_status"] = "PARTIAL"
-
-        # Test get_products
-        timestamp = datetime.now()
-        try:
-            products = wrapper.get_products(self.test_symbols)
-            self.formatter.print_request_info(
-                provider_name, f"get_products({self.test_symbols})", timestamp, "✅ SUCCESS"
-            )
-            self.formatter.print_product_table(products, f"{provider_name} Products")
-            results["tests"]["get_products"] = "SUCCESS"
-
-        except Exception as e:
-            error_msg = str(e)
-            self.formatter.print_request_info(
-                provider_name, f"get_products({self.test_symbols})", timestamp, "❌ ERROR", error_msg
-            )
-            results["tests"]["get_products"] = f"ERROR: {error_msg}"
-            results["overall_status"] = "PARTIAL"
-
-        # Test get_historical_prices
-        timestamp = datetime.now()
-        try:
-            prices = wrapper.get_historical_prices("BTC")
-            self.formatter.print_request_info(
-                provider_name, "get_historical_prices(BTC)", timestamp, "✅ SUCCESS"
-            )
-            self.formatter.print_prices_table(prices, f"{provider_name} BTC Historical Prices")
-            results["tests"]["get_historical_prices"] = "SUCCESS"
-
-        except Exception as e:
-            error_msg = str(e)
-            self.formatter.print_request_info(
-                provider_name, "get_historical_prices(BTC)", timestamp, "❌ ERROR", error_msg
-            )
-            results["tests"]["get_historical_prices"] = f"ERROR: {error_msg}"
-            results["overall_status"] = "PARTIAL"
-
-        return results
-
-def check_environment_variables() -> Dict[str, bool]:
-    """Verifica la presenza delle variabili d'ambiente necessarie."""
-    env_vars = {
-        "COINBASE_API_KEY": bool(os.getenv("COINBASE_API_KEY")),
-        "COINBASE_API_SECRET": bool(os.getenv("COINBASE_API_SECRET")),
-        "CRYPTOCOMPARE_API_KEY": bool(os.getenv("CRYPTOCOMPARE_API_KEY")),
-        "BINANCE_API_KEY": bool(os.getenv("BINANCE_API_KEY")),
-        "BINANCE_API_SECRET": bool(os.getenv("BINANCE_API_SECRET")),
-    }
-    return env_vars
-
-def initialize_providers() -> Dict[str, MarketWrapper]:
-    """Inizializza tutti i provider disponibili."""
-    providers: Dict[str, MarketWrapper] = {}
-    env_vars = check_environment_variables()
-
-    # CryptoCompareWrapper
-    if env_vars["CRYPTOCOMPARE_API_KEY"]:
-        try:
-            providers["CryptoCompare"] = CryptoCompareWrapper()
-            print("✅ CryptoCompareWrapper inizializzato con successo")
-        except Exception as e:
-            print(f"❌ Errore nell'inizializzazione di CryptoCompareWrapper: {e}")
-    else:
-        print("⚠️ CryptoCompareWrapper saltato: CRYPTOCOMPARE_API_KEY non trovata")
-
-    # CoinBaseWrapper
-    if env_vars["COINBASE_API_KEY"] and env_vars["COINBASE_API_SECRET"]:
-        try:
-            providers["CoinBase"] = CoinBaseWrapper()
-            print("✅ CoinBaseWrapper inizializzato con successo")
-        except Exception as e:
-            print(f"❌ Errore nell'inizializzazione di CoinBaseWrapper: {e}")
-    else:
-        print("⚠️ CoinBaseWrapper saltato: credenziali Coinbase non complete")
-
-    # BinanceWrapper
-    try:
-        providers["Binance"] = BinanceWrapper()
-        print("✅ BinanceWrapper inizializzato con successo")
-    except Exception as e:
-        print(f"❌ Errore nell'inizializzazione di BinanceWrapper: {e}")
-
-    # YFinanceWrapper (sempre disponibile - dati azionari e crypto gratuiti)
-    try:
-        providers["YFinance"] = YFinanceWrapper()
-        print("✅ YFinanceWrapper inizializzato con successo")
-    except Exception as e:
-        print(f"❌ Errore nell'inizializzazione di YFinanceWrapper: {e}")
-    return providers
-
-def print_summary(results: List[Dict[str, Any]]):
-    """Stampa un riassunto finale dei risultati."""
-    formatter = DemoFormatter()
-    formatter.print_header("📊 RIASSUNTO FINALE", "=", 80)
-
-    total_providers = len(results)
-    successful_providers = sum(1 for r in results if r["overall_status"] == "SUCCESS")
-    partial_providers = sum(1 for r in results if r["overall_status"] == "PARTIAL")
-
-    print(f"🔢 Provider testati: {total_providers}")
-    print(f"✅ Provider completamente funzionanti: {successful_providers}")
-    print(f"⚠️ Provider parzialmente funzionanti: {partial_providers}")
-    print(f"❌ Provider non funzionanti: {total_providers - successful_providers - partial_providers}")
-
-    print("\n📋 Dettaglio per provider:")
-    for result in results:
-        provider_name = result["provider_name"]
-        status = result["overall_status"]
-        status_icon = "✅" if status == "SUCCESS" else "⚠️" if status == "PARTIAL" else "❌"
-
-        print(f"\n{status_icon} {provider_name}:")
-        for test_name, test_result in result["tests"].items():
-            test_icon = "✅" if test_result == "SUCCESS" else "❌"
-            print(f"   {test_icon} {test_name}: {test_result}")
-
-def main():
-    """Funzione principale del demo."""
-    formatter = DemoFormatter()
-
-    # Intestazione principale
-    formatter.print_header("🚀 DEMO COMPLETO MARKET DATA PROVIDERS", "=", 80)
-
-    print(f"🕒 Avvio demo: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print("📝 Questo demo testa tutti i wrapper BaseWrapper disponibili")
-    print("🔍 Ogni test include timestamp, stato della richiesta e dati formattati")
-
-    # Verifica variabili d'ambiente
-    formatter.print_subheader("🔐 Verifica Configurazione")
-    env_vars = check_environment_variables()
-
-    print("Variabili d'ambiente:")
-    for var_name, is_present in env_vars.items():
-        status = "✅ Presente" if is_present else "❌ Mancante"
-        print(f"  {var_name}: {status}")
-
-    # Inizializza provider
-    formatter.print_subheader("🏗️ Inizializzazione Provider")
-    providers = initialize_providers()
-
-    if not providers:
-        print("❌ Nessun provider disponibile. Verifica la configurazione.")
-        return
-
-    print(f"\n🎯 Provider disponibili per il test: {list(providers.keys())}")
-
-    # Testa ogni provider
-    formatter.print_header("🧪 ESECUZIONE TEST PROVIDER", "=", 80)
-
-    tester = ProviderTester()
-    all_results: List[Dict[str, Any]] = []
-
-    for provider_name, wrapper in providers.items():
-        try:
-            result = tester.test_provider(wrapper, provider_name)
-            all_results.append(result)
-        except Exception as e:
-            print(f"❌ Errore critico nel test di {provider_name}: {e}")
-            traceback.print_exc()
-            all_results.append({
-                "provider_name": provider_name,
-                "tests": {},
-                "overall_status": "CRITICAL_ERROR",
-                "error": str(e)
-            })
-
-    # Stampa riassunto finale
-    print_summary(all_results)
-
-    # Informazioni aggiuntive
-    formatter.print_header("ℹ️ INFORMAZIONI AGGIUNTIVE", "=", 80)
-    print("📚 Documentazione:")
-    print("   - BaseWrapper: src/app/markets/base.py")
-    print("   - Test completi: tests/agents/test_market.py")
-    print("   - Configurazione: .env")
-
-    print("\n🔧 Per abilitare tutti i provider:")
-    print("   1. Configura le credenziali nel file .env")
-    print("   2. Segui la documentazione di ogni provider")
-    print("   3. Riavvia il demo")
-
-    print(f"\n🏁 Demo completato: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/demos/news_api.py b/demos/news_api.py
deleted file mode 100644
index ef71974..0000000
--- a/demos/news_api.py
+++ /dev/null
@@ -1,18 +0,0 @@
-#### FOR ALL FILES OUTSIDE src/ FOLDER ####
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
-###########################################
-
-from dotenv import load_dotenv
-from app.api.news import NewsApiWrapper
-
-def main():
-    api = NewsApiWrapper()
-    articles = api.get_latest_news(query="bitcoin", limit=5)
-    assert len(articles) > 0
-    print("ok")
-
-if __name__ == "__main__":
-    load_dotenv()
-    main()
\ No newline at end of file
diff --git a/demos/ollama_demo.py b/demos/ollama_demo.py
index 1e52f5f..8a327a6 100644
--- a/demos/ollama_demo.py
+++ b/demos/ollama_demo.py
@@ -1,20 +1,4 @@
-#!/usr/bin/env python3
-"""
-Demo di Ollama (Python) – mostra:
-    1. Elenco dei modelli disponibili
-    2. Generazione di testo semplice
-    3. Chat con streaming
-    4. Calcolo di embeddings
-    5. Esempio (opzionale) di function calling / tools
-
-Uso:
-    python ollama_demo.py
-
-Requisiti:
-    pip install ollama
-    Avviare il server Ollama (es. 'ollama serve' o l'app desktop) e avere i modelli già pullati.
-"""
-
+from typing import Any
 import ollama
 
 # Configurazione modelli
@@ -33,8 +17,8 @@ def list_models():
             print("  (Nessun modello trovato)")
             return
         for m in models:
-            name = getattr(m, 'model', None) or (m.get('model') if isinstance(m, dict) else 'sconosciuto')
-            details = getattr(m, 'details', None)
+            name = getattr(m, 'model', None) or (m.get('model') if isinstance(m, dict) else 'sconosciuto')  # type: ignore
+            details = getattr(m, 'details', None)  # type: ignore
             fmt = getattr(details, 'format', None) if details else 'unknown'
             print(f"  • {name} – {fmt}")
     except Exception as e:
@@ -46,7 +30,7 @@ def list_models():
 def generate_text(model: str, prompt: str, max_tokens: int = 200) -> str:
     """Genera testo dal modello indicato."""
     print(f"\n[2] Generazione testo con '{model}'")
-    response = ollama.chat(
+    response = ollama.chat(  # type: ignore
         model=model,
         messages=[{"role": "user", "content": prompt}]
     )
@@ -57,10 +41,10 @@ def generate_text(model: str, prompt: str, max_tokens: int = 200) -> str:
 
 # 3. Chat con streaming --------------------------------------------------------
 
-def chat_streaming(model: str, messages: list) -> str:
+def chat_streaming(model: str, messages: list[dict[str, str]]) -> str:
     """Esegue una chat mostrando progressivamente la risposta."""
     print(f"\n[3] Chat (streaming) con '{model}'")
-    stream = ollama.chat(model=model, messages=messages, stream=True)
+    stream = ollama.chat(model=model, messages=messages, stream=True)  # type: ignore
     full = ""
     for chunk in stream:
         if 'message' in chunk and 'content' in chunk['message']:
@@ -91,7 +75,7 @@ def get_embedding(model: str, text: str):
 def try_tools(model: str):
     """Esempio di function calling; se non supportato mostra messaggio informativo."""
     print(f"\n[5] Function calling / tools con '{model}'")
-    tools = [
+    tools: list[dict[str, Any]] = [
         {
             "type": "function",
             "function": {
@@ -109,7 +93,7 @@ def try_tools(model: str):
         }
     ]
     try:
-        response = ollama.chat(
+        response = ollama.chat(  # type: ignore
             model=model,
             messages=[{"role": "user", "content": "Che tempo fa a Milano?"}],
             tools=tools
-- 
2.49.1


From 71a984a6190db0c21b8d27d1b88561d08f88a089 Mon Sep 17 00:00:00 2001
From: Berack96 <giacomobertolazzi7@gmail.com>
Date: Wed, 22 Oct 2025 09:44:49 +0200
Subject: [PATCH 5/6] Aggiornata la documentazione dell'architettura dell'app

---
 docs/App_Architecture_Diagrams.md | 743 ++++++------------------------
 1 file changed, 133 insertions(+), 610 deletions(-)

diff --git a/docs/App_Architecture_Diagrams.md b/docs/App_Architecture_Diagrams.md
index 792d05c..6eb4308 100644
--- a/docs/App_Architecture_Diagrams.md
+++ b/docs/App_Architecture_Diagrams.md
@@ -1,637 +1,160 @@
-# 📊 Architettura e Flussi dell'App upo-appAI
+# 📊 Architettura upo-appAI
 
-## 🏗️ Diagramma Architettura Generale
+## 🏗️ Architettura Generale
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                   🌐 INTERFACCE UTENTE                          │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │             💬 Gradio Web Interface                        │ │
-│  │  ┌──────────┐  ┌──────────┐  ┌───────────────────────┐   │ │
-│  │  │  Chat    │  │  Model   │  │  Strategy (Strategy)  │   │ │
-│  │  │ History  │  │Dropdown  │  │  - Conservative       │   │ │
-│  │  │          │  │          │  │  - Aggressive         │   │ │
-│  │  └──────────┘  └──────────┘  └───────────────────────┘   │ │
-│  └────────────────────────────────────────────────────────────┘ │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │             📱 Telegram Bot Interface                      │ │
-│  │         (Mini App con integrazione Gradio)                 │ │
-│  └────────────────────────────────────────────────────────────┘ │
-└─────────────────────────┬───────────────────────────────────────┘
-                          │
-                          ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                    🎯 CHAT MANAGER                              │
-│               (Gestione Conversazioni)                          │
-│  ┌─────────────────────────────────────────────────────────┐   │
-│  │ - Mantiene storico messaggi (history)                   │   │
-│  │ - Gestisce input Pipeline (PipelineInputs)              │   │
-│  │ - Salva/Carica chat (JSON)                              │   │
-│  │ - Interfaccia Gradio (gradio_build_interface)           │   │
-│  └─────────────────────────────────────────────────────────┘   │
-└─────────────────────────┬───────────────────────────────────────┘
-                          │
-                          ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                    🔄 AGNO WORKFLOW PIPELINE                   │
-│                  (Orchestrazione Asincrona)                     │
-│                                                                 │
-│  Step 1: 🔍 Query Check         → Verifica query crypto        │
-│  Step 2: 🤔 Condition Check     → Valida se procedere          │
-│  Step 3: 📊 Info Recovery       → Team di raccolta dati        │
-│  Step 4: 📝 Report Generation   → Genera report finale         │
-│                                                                 │
-│  Pipeline Events: QUERY_CHECK | QUERY_ANALYZER |               │
-│                   INFO_RECOVERY | REPORT_GENERATION |          │
-│                   TOOL_USED | RUN_FINISHED                      │
-└─────────────────────────┬───────────────────────────────────────┘
-                          │
-                          ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                   🤖 AGNO AGENT ECOSYSTEM                       │
-│                                                                 │
-│ ┌───────────────────────────────────────────────────────────┐  │
-│ │             👔 TEAM LEADER (Agno Team)                    │  │
-│ │  - Coordina Market, News, Social Agents                   │  │
-│ │  - Tools: ReasoningTools, PlanMemoryTool,                 │  │
-│ │           CryptoSymbolsTools                              │  │
-│ │  - Model: Configurabile (team_leader_model)               │  │
-│ └───────────────────────────────────────────────────────────┘  │
-│         │                      │                      │         │
-│         ▼                      ▼                      ▼         │
-│ ┌─────────────┐       ┌─────────────┐       ┌─────────────┐   │
-│ │   MARKET    │       │    NEWS     │       │   SOCIAL    │   │
-│ │   AGENT     │       │   AGENT     │       │   AGENT     │   │
-│ │  (Agno)     │       │  (Agno)     │       │  (Agno)     │   │
-│ │             │       │             │       │             │   │
-│ │ Tool:       │       │ Tool:       │       │ Tool:       │   │
-│ │ MarketAPIs  │       │ NewsAPIs    │       │ SocialAPIs  │   │
-│ │ Tool        │       │ Tool        │       │ Tool        │   │
-│ └─────────────┘       └─────────────┘       └─────────────┘   │
-│                                                                 │
-│ ┌───────────────────────────────────────────────────────────┐  │
-│ │           � QUERY CHECK AGENT (Agno Agent)              │  │
-│ │  - Valida se la query è relativa a crypto                │  │
-│ │  - Output Schema: QueryOutputs (is_crypto: bool)          │  │
-│ └───────────────────────────────────────────────────────────┘  │
-│                                                                 │
-│ ┌───────────────────────────────────────────────────────────┐  │
-│ │        📋 REPORT GENERATOR AGENT (Agno Agent)            │  │
-│ │  - Genera report finale basato su dati raccolti           │  │
-│ │  - Applica strategia (Conservative/Aggressive)            │  │
-│ └───────────────────────────────────────────────────────────┘  │
-└─────────────────────────────────────────────────────────────────┘
+INTERFACCE UTENTE
+├── 💬 Gradio Web (Chat + Dropdown modelli/strategie)
+└── 📱 Telegram Bot (Mini App)
+       │
+       ▼
+CHAT MANAGER
+├── Storico messaggi
+├── Gestione PipelineInputs
+└── Salva/Carica chat
+       │
+       ▼
+AGNO WORKFLOW PIPELINE (4 Steps)
+├── 1. Query Check → Verifica crypto
+├── 2. Condition → Valida procedere
+├── 3. Info Recovery → Team raccolta dati
+└── 4. Report Generation → Report finale
+       │
+       ▼
+AGNO AGENT ECOSYSTEM
+├── 👔 TEAM LEADER (coordina Market, News, Social)
+│   Tools: ReasoningTools, PlanMemoryTool, CryptoSymbolsTools
+├── 📈 MARKET AGENT → MarketAPIsTool
+├── 📰 NEWS AGENT → NewsAPIsTool
+├── 🐦 SOCIAL AGENT → SocialAPIsTool
+├── 🔍 QUERY CHECK AGENT → QueryOutputs (is_crypto: bool)
+└── 📋 REPORT GENERATOR AGENT → Strategia applicata
 ```
 
-## 🔄 Flusso di Esecuzione Dettagliato
+## 🔄 Flusso Esecuzione
 
-```
-👤 USER REQUEST
-    │
-    │ "Analizza Bitcoin con strategia aggressiva"
-    ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                   � CHAT MANAGER                               │
-│                                                                  │
-│  - Riceve messaggio utente                                      │
-│  - Gestisce history della conversazione                         │
-│  - Prepara PipelineInputs con:                                  │
-│    * user_query: "Analizza Bitcoin..."                          │
-│    * strategy: "aggressive"                                     │
-│    * models: team_leader_model, team_model, etc.                │
-└─────────────────────────────────────────────────────────────────┘
-    │
-    ▼
-┌─────────────────────────────────────────────────────────────────┐
-│              🔄 AGNO WORKFLOW PIPELINE                          │
-│                                                                  │
-│  Run ID: [3845] Pipeline query: "Analizza Bitcoin..."          │
-│                                                                  │
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │ STEP 1: 🔍 QUERY CHECK (Query Check Agent)              │  │
-│  │                                                          │  │
-│  │  Input: QueryInputs(user_query, strategy)               │  │
-│  │  Agent: query_analyzer_model (Agno Agent)               │  │
-│  │  Output: QueryOutputs(response, is_crypto: bool)        │  │
-│  │                                                          │  │
-│  │  Result: {"is_crypto": true, "response": "..."}         │  │
-│  │  Event: QUERY_CHECK completed                           │  │
-│  └──────────────────────────────────────────────────────────┘  │
-    │
-    ▼
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │ STEP 2: 🤔 CONDITION CHECK                               │  │
-│  │                                                          │  │
-│  │  Valida: previous_step_content.is_crypto                │  │
-│  │  If False → StopOutput(stop=True)                       │  │
-│  │  If True  → Continua al prossimo step                   │  │
-│  └──────────────────────────────────────────────────────────┘  │
-    │
-    ▼
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │ STEP 3: 📊 INFO RECOVERY (Team)                         │  │
-│  │                                                          │  │
-│  │  👔 Team Leader coordina:                               │  │
-│  │     ├── 📈 Market Agent → MarketAPIsTool                │  │
-│  │     ├── 📰 News Agent   → NewsAPIsTool                  │  │
-│  │     └── 🐦 Social Agent → SocialAPIsTool                │  │
-│  │                                                          │  │
-│  │  Tools disponibili al Team Leader:                      │  │
-│  │     - ReasoningTools (ragionamento)                     │  │
-│  │     - PlanMemoryTool (memoria del piano)                │  │
-│  │     - CryptoSymbolsTools (simboli crypto)               │  │
-│  │                                                          │  │
-│  │  Events: TOOL_USED per ogni chiamata tool               │  │
-│  │  Event: INFO_RECOVERY completed                         │  │
-│  └──────────────────────────────────────────────────────────┘  │
-    │
-    ▼
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │ STEP 4: 📝 REPORT GENERATION (Report Generator Agent)   │  │
-│  │                                                          │  │
-│  │  Input: Tutti i dati raccolti da Info Recovery          │  │
-│  │  Agent: report_generation_model (Agno Agent)            │  │
-│  │  Strategia: Applicata dal prompt (aggressive)           │  │
-│  │                                                          │  │
-│  │  Output: Report finale con raccomandazioni              │  │
-│  │  Event: REPORT_GENERATION completed                     │  │
-│  └──────────────────────────────────────────────────────────┘  │
-    │
-    ▼
-│  Event: RUN_FINISHED                                            │
-│  Return: Final report string (rimozione tag <think>)            │
-└─────────────────────────────────────────────────────────────────┘
-    │
-    ▼
-📋 FINAL OUTPUT TO USER
-┌─────────────────────────────────────────────────────────────────┐
-│  📊 Analisi Bitcoin (BTC)                                       │
-│                                                                  │
-│  � Dati di Mercato:                                            │
-│     - Prezzo: $63,516 (aggregato da 4 fonti)                   │
-│     - Volume 24h: $2.1M                                         │
-│     - Confidence: 94%                                           │
-│                                                                  │
-│  📰 Sentiment News: Positivo (istituzionale in crescita)       │
-│  🐦 Sentiment Social: Bullish (Reddit/Twitter +15%)            │
-│                                                                  │
-│  🎯 Raccomandazione (Strategia Aggressiva):                    │
-│     STRONG BUY - Allocazione 15-20% del portfolio              │
-│                                                                  │
-│  💭 Ragionamento: [dettagli dell'analisi...]                   │
-└─────────────────────────────────────────────────────────────────┘
+**Input:** "Analizza Bitcoin con strategia aggressiva"
+
+1. CHAT MANAGER riceve e prepara PipelineInputs
+2. WORKFLOW PIPELINE esegue 4 step:
+   - Query Check: valida `is_crypto: true`
+   - Condition: se false, termina
+   - Info Recovery: Team raccoglie dati
+   - Report Generation: genera report
+3. OUTPUT: Report con analisi + raccomandazioni
+
+## 🏛️ Architettura API
+
+**Tools (Agno Toolkit):**
+- MarketAPIsTool: Binance, YFinance, CoinBase, CryptoCompare
+- NewsAPIsTool: NewsAPI, GoogleNews, DuckDuckGo, CryptoPanic
+- SocialAPIsTool: Reddit, X, 4chan
+- CryptoSymbolsTools: `resources/cryptos.csv`
+
+**WrapperHandler:** Failover automatico (3 tentativi/wrapper, 2s delay)
+
+## 📊 Data Aggregation
+
+**ProductInfo:**
+- Volume: media tra sources
+- Price: weighted average (price × volume)
+- Confidence: spread + numero sources
+
+**Historical Price:**
+- Align per timestamp
+- Media: high, low, open, close, volume
+
+## 🎯 Configuration
+
+**configs.yaml:**
+```yaml
+port: 8000
+models: [Ollama, OpenAI, Anthropic, Google]
+strategies: [Conservative, Aggressive]
+agents: {team_model, team_leader_model, ...}
+api: {retry_attempts: 3, retry_delay_seconds: 2}
 ```
 
-## 🏛️ Architettura API e Tools
+**.env (API Keys):**
+- Market: CDP_API_KEY, CRYPTOCOMPARE_API_KEY, ...
+- News: NEWS_API_KEY, CRYPTOPANIC_API_KEY, ...
+- Social: REDDIT_CLIENT_ID, X_API_KEY, ...
+- LLM: OPENAI_API_KEY, ANTHROPIC_API_KEY, ...
+- Bot: TELEGRAM_BOT_TOKEN
+
+## 🗂️ Struttura Progetto
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                  � API TOOLS ARCHITECTURE                      │
-│                  (Agno Toolkit Integration)                     │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │         📊 MarketAPIsTool (Agno Toolkit)              │    │
-│  │                                                        │    │
-│  │  Tools disponibili:                                    │    │
-│  │  - get_product(asset_id)                              │    │
-│  │  - get_products(asset_ids)                            │    │
-│  │  - get_historical_prices(asset_id, limit)             │    │
-│  │  - get_products_aggregated(asset_ids)                 │    │
-│  │  - get_historical_prices_aggregated(asset_id, limit)  │    │
-│  │                                                        │    │
-│  │  🔄 WrapperHandler gestisce:                          │    │
-│  │  ┌──────────────┐  ┌──────────────┐                   │    │
-│  │  │  Binance     │  │  YFinance    │                   │    │
-│  │  │  Wrapper     │  │  Wrapper     │                   │    │
-│  │  └──────────────┘  └──────────────┘                   │    │
-│  │  ┌──────────────┐  ┌──────────────┐                   │    │
-│  │  │  CoinBase    │  │CryptoCompare │                   │    │
-│  │  │  Wrapper     │  │  Wrapper     │                   │    │
-│  │  └──────────────┘  └──────────────┘                   │    │
-│  │                                                        │    │
-│  │  Retry Logic: 3 tentativi per wrapper, 2s delay       │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │         📰 NewsAPIsTool (Agno Toolkit)                │    │
-│  │                                                        │    │
-│  │  🔄 WrapperHandler gestisce:                          │    │
-│  │  - NewsAPI Wrapper                                     │    │
-│  │  - GoogleNews Wrapper                                  │    │
-│  │  - DuckDuckGo Wrapper                                  │    │
-│  │  - CryptoPanic Wrapper                                 │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │         🐦 SocialAPIsTool (Agno Toolkit)              │    │
-│  │                                                        │    │
-│  │  🔄 WrapperHandler gestisce:                          │    │
-│  │  - Reddit Wrapper                                      │    │
-│  │  - X (Twitter) Wrapper                                 │    │
-│  │  - 4chan Wrapper                                       │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │         🔣 CryptoSymbolsTools (Agno Toolkit)          │    │
-│  │  - Gestisce simboli e nomi delle criptovalute          │    │
-│  │  - Carica da resources/cryptos.csv                     │    │
-│  └────────────────────────────────────────────────────────┘    │
-└─────────────────────────────────────────────────────────────────┘
-```
+src/app/
+├── __main__.py
+├── configs.py
+├── agents/
+│   ├── core.py
+│   ├── pipeline.py
+│   ├── plan_memory_tool.py
+│   └── prompts/
+├── api/
+│   ├── wrapper_handler.py
+│   ├── core/ (markets, news, social)
+│   ├── markets/ (Binance, CoinBase, CryptoCompare, YFinance)
+│   ├── news/ (NewsAPI, GoogleNews, DuckDuckGo, CryptoPanic)
+│   ├── social/ (Reddit, X, 4chan)
+│   └── tools/ (Agno Toolkits)
+└── interface/ (chat.py, telegram_app.py)
 
-## � WrapperHandler Pattern
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    � WRAPPER HANDLER                           │
-│              (Resilient API Call Management)                    │
-│                                                                 │
-│  Input: List[WrapperType]                                      │
-│         try_per_wrapper: int = 3                               │
-│         retry_delay: int = 2                                   │
-│                                                                 │
-│  ┌───────────────────────────────────────────────────────────┐ │
-│  │ def try_call(func: Callable) -> OutputType:              │ │
-│  │                                                           │ │
-│  │   for wrapper in wrappers:                               │ │
-│  │     for attempt in range(try_per_wrapper):               │ │
-│  │       try:                                               │ │
-│  │         result = func(wrapper)                           │ │
-│  │         return result  # ✅ Success                      │ │
-│  │       except Exception as e:                             │ │
-│  │         log_error(e)                                     │ │
-│  │         sleep(retry_delay)                               │ │
-│  │         continue  # � Retry                             │ │
-│  │                                                           │ │
-│  │     # Switch to next wrapper                             │ │
-│  │                                                           │ │
-│  │   raise Exception("All wrappers failed")  # ❌ All fail  │ │
-│  └───────────────────────────────────────────────────────────┘ │
-│                                                                 │
-│  Esempio Flusso:                                               │
-│  ┌─────────┐  Fail   ┌─────────┐  Fail   ┌─────────┐         │
-│  │Binance  │────────▶│YFinance │────────▶│CoinBase │  ✅     │
-│  │(3 tries)│         │(3 tries)│         │(Success)│         │
-│  └─────────┘         └─────────┘         └─────────┘         │
-│                                                                 │
-│  Features:                                                     │
-│  ✅ Automatic failover tra providers                           │
-│  ✅ Retry logic configurabile                                  │
-│  ✅ Logging dettagliato degli errori                           │
-│  ✅ Type-safe con Generics                                     │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## � Data Aggregation Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│              📊 PRODUCT INFO AGGREGATION                        │
-│                                                                 │
-│  Input: dict[provider_name, list[ProductInfo]]                 │
-│                                                                 │
-│  Provider A: BTC → {price: 63500, volume: 1.2M}                │
-│  Provider B: BTC → {price: 63450, volume: N/A}                 │
-│  Provider C: BTC → {price: 63600, volume: 2.1M}                │
-│  Provider D: BTC → {price: 63550, volume: 1.8M}                │
-│                                                                 │
-│  ┌───────────────────────────────────────────────────────────┐ │
-│  │ Aggregation Logic:                                        │ │
-│  │                                                           │ │
-│  │ 1. Group by symbol (BTC, ETH, etc.)                      │ │
-│  │                                                           │ │
-│  │ 2. Aggregate Volume:                                     │ │
-│  │    avg_volume = sum(volumes) / count(providers)          │ │
-│  │                                                           │ │
-│  │ 3. Aggregate Price (weighted by volume):                 │ │
-│  │    weighted_price = sum(price * volume) / sum(volume)    │ │
-│  │                                                           │ │
-│  │ 4. Calculate Confidence:                                 │ │
-│  │    - Based on price spread                               │ │
-│  │    - Number of sources                                   │ │
-│  │    - Volume consistency                                  │ │
-│  └───────────────────────────────────────────────────────────┘ │
-│                                                                 │
-│  Output: list[ProductInfo]                                     │
-│  {                                                              │
-│    "id": "BTC_AGGREGATED",                                     │
-│    "symbol": "BTC",                                            │
-│    "price": 63516.67,  # Weighted average                      │
-│    "volume_24h": 1.7M,  # Average volume                       │
-│    "currency": "USD",                                          │
-│    "confidence": 0.94  # High confidence (low spread)          │
-│  }                                                              │
-└─────────────────────────────────────────────────────────────────┘
-
-┌─────────────────────────────────────────────────────────────────┐
-│           📈 HISTORICAL PRICE AGGREGATION                       │
-│                                                                 │
-│  Input: dict[provider_name, list[Price]]                       │
-│                                                                 │
-│  ┌───────────────────────────────────────────────────────────┐ │
-│  │ Aggregation Logic:                                        │ │
-│  │                                                           │ │
-│  │ 1. Align by timestamp (YYYY-MM-DD HH:MM)                 │ │
-│  │                                                           │ │
-│  │ 2. For each timestamp, calculate mean of:                │ │
-│  │    - high                                                 │ │
-│  │    - low                                                  │ │
-│  │    - open                                                 │ │
-│  │    - close                                                │ │
-│  │    - volume                                               │ │
-│  │                                                           │ │
-│  │ 3. Handle missing data gracefully                        │ │
-│  └───────────────────────────────────────────────────────────┘ │
-│                                                                 │
-│  Output: list[Price] (aggregated by timestamp)                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 🎯 Configuration Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                  ⚙️ APP CONFIG (configs.yaml)                   │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │  port: 7860  # Gradio server port                     │    │
-│  │  gradio_share: false  # Public sharing                │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │  models:  # LLM Models Configuration                  │    │
-│  │    - label: "Qwen 3 (4B)"                             │    │
-│  │      provider: "ollama"                               │    │
-│  │      model_id: "qwen3:4b"                             │    │
-│  │    - label: "Qwen 3 (1.7B)"                           │    │
-│  │      provider: "ollama"                               │    │
-│  │      model_id: "qwen3:1.7b"                           │    │
-│  │    - label: "GPT-4 Turbo"                             │    │
-│  │      provider: "openai"                               │    │
-│  │      model_id: "gpt-4-turbo"                          │    │
-│  │      api_key_env: "OPENAI_API_KEY"                    │    │
-│  │    # ... altri modelli (Anthropic, Google, etc.)      │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │  strategies:  # Investment Strategies                 │    │
-│  │    - label: "Conservative"                            │    │
-│  │      description: "Low risk, stable returns..."       │    │
-│  │    - label: "Aggressive"                              │    │
-│  │      description: "High risk, high potential..."      │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │  agents:  # Agent-specific configurations             │    │
-│  │    team_model: "qwen3:4b"                             │    │
-│  │    team_leader_model: "qwen3:4b"                      │    │
-│  │    query_analyzer_model: "qwen3:1.7b"                 │    │
-│  │    report_generation_model: "qwen3:4b"                │    │
-│  │    strategy: "Conservative"                           │    │
-│  └────────────────────────────────────────────────────────┘    │
-│                                                                 │
-│  ┌────────────────────────────────────────────────────────┐    │
-│  │  api:  # API Configuration                            │    │
-│  │    retry_attempts: 3                                  │    │
-│  │    retry_delay_seconds: 2                             │    │
-│  └────────────────────────────────────────────────────────┘    │
-└─────────────────────────────────────────────────────────────────┘
-
-┌─────────────────────────────────────────────────────────────────┐
-│              🔐 ENVIRONMENT VARIABLES (.env)                    │
-│                                                                 │
-│  # Market APIs                                                 │
-│  CDP_API_KEY_NAME=...          # Coinbase                      │
-│  CDP_API_PRIVATE_KEY=...       # Coinbase                      │
-│  CRYPTOCOMPARE_API_KEY=...     # CryptoCompare                 │
-│  BINANCE_API_KEY=...           # Binance (future)              │
-│                                                                 │
-│  # News APIs                                                   │
-│  NEWS_API_KEY=...              # NewsAPI                       │
-│  CRYPTOPANIC_API_KEY=...       # CryptoPanic                   │
-│                                                                 │
-│  # Social APIs                                                 │
-│  REDDIT_CLIENT_ID=...          # Reddit                        │
-│  REDDIT_CLIENT_SECRET=...      # Reddit                        │
-│  X_BEARER_TOKEN=...            # Twitter/X                     │
-│                                                                 │
-│  # LLM Providers                                               │
-│  OPENAI_API_KEY=...            # OpenAI                        │
-│  ANTHROPIC_API_KEY=...         # Anthropic                     │
-│  GOOGLE_API_KEY=...            # Google                        │
-│                                                                 │
-│  # Telegram Bot                                                │
-│  TELEGRAM_BOT_TOKEN=...        # Telegram Bot                  │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 🗂️ Struttura del Progetto
-
-```
-upo-appAI/
-│
-├── 📁 src/app/                      # Codice principale
-│   ├── __main__.py                  # Entry point (Gradio + Telegram)
-│   ├── configs.py                   # Gestione configurazioni
-│   │
-│   ├── 📁 agents/                   # Sistema di agenti Agno
-│   │   ├── core.py                  # PipelineInputs, QueryInputs/Outputs
-│   │   ├── pipeline.py              # Workflow Pipeline con Agno
-│   │   ├── plan_memory_tool.py      # Tool per memoria del piano
-│   │   └── 📁 prompts/              # Prompt per gli agenti
-│   │       ├── query_check.txt      # Prompt Query Checker
-│   │       ├── team_leader.txt      # Prompt Team Leader
-│   │       ├── team_market.txt      # Prompt Market Agent
-│   │       ├── team_news.txt        # Prompt News Agent
-│   │       ├── team_social.txt      # Prompt Social Agent
-│   │       └── report_generation.txt # Prompt Report Generator
-│   │
-│   ├── 📁 api/                      # Layer API e Wrappers
-│   │   ├── wrapper_handler.py       # Pattern WrapperHandler generico
-│   │   │
-│   │   ├── 📁 core/                 # Interfacce base e modelli
-│   │   │   ├── markets.py           # MarketWrapper, ProductInfo, Price
-│   │   │   ├── news.py              # NewsWrapper, NewsItem
-│   │   │   └── social.py            # SocialWrapper, SocialPost
-│   │   │
-│   │   ├── 📁 markets/              # Implementazioni Market API
-│   │   │   ├── binance.py           # BinanceWrapper
-│   │   │   ├── coinbase.py          # CoinBaseWrapper
-│   │   │   ├── cryptocompare.py     # CryptoCompareWrapper
-│   │   │   └── yfinance.py          # YFinanceWrapper
-│   │   │
-│   │   ├── 📁 news/                 # Implementazioni News API
-│   │   │   ├── newsapi.py           # NewsAPIWrapper
-│   │   │   ├── googlenews.py        # GoogleNewsWrapper
-│   │   │   ├── duckduckgo.py        # DuckDuckGoWrapper
-│   │   │   └── cryptopanic_api.py   # CryptoPanicWrapper
-│   │   │
-│   │   ├── 📁 social/               # Implementazioni Social API
-│   │   │   ├── reddit.py            # RedditWrapper
-│   │   │   ├── x.py                 # XWrapper (Twitter)
-│   │   │   └── chan.py              # 4ChanWrapper
-│   │   │
-│   │   └── 📁 tools/                # Agno Toolkits
-│   │       ├── market_tool.py       # MarketAPIsTool (Agno Toolkit)
-│   │       ├── news_tool.py         # NewsAPIsTool (Agno Toolkit)
-│   │       ├── social_tool.py       # SocialAPIsTool (Agno Toolkit)
-│   │       └── symbols_tool.py      # CryptoSymbolsTools (Agno Toolkit)
-│   │
-│   └── 📁 interface/                # Interfacce utente
-│       ├── chat.py                  # ChatManager (Gradio)
-│       └── telegram_app.py          # TelegramApp (Bot)
-│
-├── 📁 tests/                        # Test suite completa
-│   ├── conftest.py                  # Configurazione pytest
-│   ├── 📁 agents/                   # Test agenti
-│   ├── 📁 api/                      # Test API wrappers
-│   ├── 📁 tools/                    # Test tools
-│   └── 📁 utils/                    # Test utilities
-│
-├── 📁 demos/                        # Script di esempio
-│   ├── agno_agent.py                # Demo Agno Agent
-│   ├── agno_workflow.py             # Demo Agno Workflow
-│   ├── coinbase_demo.py             # Demo Coinbase API
-│   ├── cryptocompare_demo.py        # Demo CryptoCompare API
-│   └── market_providers_api_demo.py # Demo aggregazione provider
-│
-├── 📁 resources/                    # Risorse statiche
-│   └── cryptos.csv                  # Database simboli crypto
-│
-├── 📁 docs/                         # Documentazione
-│   ├── App_Architecture_Diagrams.md # Questo file
-│   └── Progetto Esame.md            # Specifiche progetto
-│
-├── configs.yaml                     # Configurazione app (modelli, strategie)
-├── .env                             # Variabili d'ambiente (API keys)
-├── .env.example                     # Template per .env
-├── pyproject.toml                   # Dipendenze Python (uv/pip)
-├── Dockerfile                       # Container Docker
-├── docker-compose.yaml              # Orchestrazione Docker
-└── README.md                        # Documentazione principale
+tests/
+demos/
+resources/cryptos.csv
+docs/
+configs.yaml
+.env
 ```
 
 ## 🔑 Componenti Chiave
 
-### 1. **Agno Framework Integration**
-L'applicazione utilizza il framework **Agno** per gestire:
-- **Agent**: Singoli agenti con modelli LLM specifici
-- **Team**: Coordinazione di più agenti sotto un Team Leader
-- **Workflow**: Pipeline asincrone con step condizionali
-- **Toolkit**: Integrazione tools con retry logic
-- **RunEvent**: Sistema di eventi per monitoraggio
+1. **Agno Framework**: Agent, Team, Workflow, Toolkit, RunEvent
+2. **WrapperHandler**: Failover, Retry logic, Type safety
+3. **Data Aggregation**: Multiple sources, Confidence score
+4. **Multi-Interface**: Gradio + Telegram
+5. **Configuration**: configs.yaml + .env
 
-### 2. **WrapperHandler Pattern**
-Pattern generico per gestire multiple implementazioni API con:
-- Failover automatico tra provider
-- Retry logic configurabile
-- Type safety con Generics
-- Logging dettagliato
+## 🚀 Deployment
 
-### 3. **Data Aggregation**
-Sistema sofisticato di aggregazione che:
-- Combina dati da multiple fonti
-- Calcola confidence score
-- Gestisce dati mancanti/inconsistenti
-- Fornisce weighted averages
-
-### 4. **Multi-Interface Support**
-Due interfacce integrate:
-- **Gradio Web UI**: Chat interface con dropdown per modelli/strategie
-- **Telegram Bot**: Bot con Mini App integrato
-
-### 5. **Configuration Management**
-Sistema a due livelli:
-- **configs.yaml**: Configurazioni applicazione (modelli, strategie, agenti)
-- **.env**: Secrets e API keys (caricato con dotenv)
-
-## 🚀 Deployment Flow
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    🐳 DOCKER DEPLOYMENT                         │
-│                                                                 │
-│  1. Load .env variables                                        │
-│  2. Build Docker image (Python 3.11)                           │
-│  3. Install dependencies (pyproject.toml)                      │
-│  4. Copy src/, configs.yaml, resources/                        │
-│  5. Expose port 7860 (Gradio)                                  │
-│  6. Run: python -m src.app                                     │
-│                                                                 │
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │  docker-compose up --build -d                            │  │
-│  │                                                          │  │
-│  │  Services:                                               │  │
-│  │  - app: Main application (Gradio + Telegram)            │  │
-│  │  - Networks: Bridge mode                                │  │
-│  │  - Volumes: .env mounted                                │  │
-│  └──────────────────────────────────────────────────────────┘  │
-└─────────────────────────────────────────────────────────────────┘
-
-┌─────────────────────────────────────────────────────────────────┐
-│                 💻 LOCAL DEVELOPMENT (UV)                       │
-│                                                                 │
-│  1. Install uv package manager                                 │
-│  2. uv venv (create virtual environment)                       │
-│  3. uv pip install -e . (editable install)                     │
-│  4. uv run src/app (run application)                           │
-│                                                                 │
-│  Benefits:                                                     │
-│  ✅ Fast dependency resolution                                 │
-│  ✅ Automatic PYTHONPATH setup                                 │
-│  ✅ Editable mode for development                              │
-└─────────────────────────────────────────────────────────────────┘
+**Docker:**
+```bash
+docker-compose up --build -d
 ```
 
-## 🎯 Workflow Execution Model
+**Local (UV):**
+```bash
+uv venv
+uv pip install -e .
+uv run src/app
+```
 
-L'applicazione utilizza un modello di esecuzione **Asincrono** basato su Agno Workflow:
+## 🎯 Workflow Asincrono
 
 ```python
-# Pipeline di esecuzione
-async def interact_async():
-    workflow = Workflow(steps=[
-        query_check,         # Step 1: Verifica query
-        condition_query_ok,  # Step 2: Condizione
-        info_recovery,       # Step 3: Team di raccolta
-        report_generation    # Step 4: Report finale
-    ])
-    
-    # Esecuzione con streaming
-    iterator = await workflow.arun(
-        query,
-        stream=True,
-        stream_intermediate_steps=True
-    )
-    
-    # Event handling
-    async for event in iterator:
-        if event.event == PipelineEvent.TOOL_USED:
-            log(f"Tool: {event.tool.tool_name}")
-        elif event.event == WorkflowRunEvent.step_completed:
-            log(f"Step: {event.step_name} completed")
+workflow = Workflow(steps=[
+    query_check, condition,
+    info_recovery, report_generation
+])
+
+iterator = await workflow.arun(query, stream=True)
+
+async for event in iterator:
+    if event.event == PipelineEvent.TOOL_USED:
+        log(f"Tool: {event.tool.tool_name}")
 ```
 
-**Vantaggi:**
-- ⚡ Esecuzione asincrona per migliori performance
-- 📊 Streaming di eventi intermedi
-- 🎯 Gestione condizionale del flusso
-- 🔄 Retry automatico sui tools
+**Vantaggi:** Asincrono, Streaming, Condizionale, Retry
 
 ## 📈 Future Enhancements
 
-Possibili miglioramenti architetturali:
-
-1. **Parallel Tool Execution**: Esecuzione parallela di Market/News/Social agents
-2. **Caching Layer**: Redis/Memcached per ridurre chiamate API
-3. **Database Integration**: PostgreSQL per storico analisi
-4. **Real-time WebSocket**: Aggiornamenti live prezzi
-5. **ML Model Integration**: Modelli predittivi custom (LSTM, Transformer)
-6. **Advanced Aggregation**: Confidence scoring migliorato con ML
-7. **User Profiles**: Personalizzazione strategie per utente
-8. **Backtesting Module**: Validazione strategie su dati storici
-
----
-*Documento aggiornato: 2025-10-22*
-*Sistema: upo-appAI Crypto Analysis Platform*
-*Framework: Agno (Agentic AI) + Gradio + Telegram*
\ No newline at end of file
+- Parallel Tool Execution
+- Caching (Redis)
+- Database (PostgreSQL)
+- Real-time WebSocket
+- ML Models
+- User Profiles
+- Backtesting
-- 
2.49.1


From 6ff2fcc2a7c61fd3768c4f0392dd5f71a4c87ffc Mon Sep 17 00:00:00 2001
From: Nunzi99 <115243475+Nunzi99@users.noreply.github.com>
Date: Sun, 26 Oct 2025 14:07:44 +0100
Subject: [PATCH 6/6] Aggiungere LLM Providers (#48)

* Refactor configs dei modelli
* Aggiunti Providers
---
 .env.example              |   9 ++-
 configs.yaml              |  12 ++++
 pyproject.toml            |   4 ++
 src/app/configs.py        | 121 +++++++++++++++++++++-----------------
 src/app/interface/chat.py |   6 +-
 5 files changed, 96 insertions(+), 56 deletions(-)

diff --git a/.env.example b/.env.example
index 694300e..b999e0e 100644
--- a/.env.example
+++ b/.env.example
@@ -5,7 +5,14 @@
 # https://makersuite.google.com/app/apikey
 GOOGLE_API_KEY=
 
-
+# https://platform.openai.com/settings/organization/api-keys
+OPENAI_API_KEY=
+# https://admin.mistral.ai/organization/api-keys
+MISTRAL_API_KEY=
+# https://platform.deepseek.com/api_keys
+DEEPSEEK_API_KEY=
+# https://console.x.ai/team/%TEAM_ID%/api-keys
+XAI_API_KEY=
 ###############################################################################
 # Configurazioni per gli agenti di mercato
 ###############################################################################
diff --git a/configs.yaml b/configs.yaml
index f83ae9e..615fcf8 100644
--- a/configs.yaml
+++ b/configs.yaml
@@ -19,6 +19,18 @@ models:
       label: Gemini
     # - name: gemini-2.0-pro # TODO Non funziona, ha un nome diverso
     #   label: Gemini Pro
+  gpt:
+    - name: gpt-4o
+      label: OpenAIChat
+  deepseek:
+    - name: deepseek-chat
+      label: DeepSeek
+  xai:
+    - name: grok-3
+      label: xAI
+  mistral:
+    - name: mistral-large-latest
+      label: Mistral
   ollama:
     - name: gpt-oss:latest
       label: Ollama GPT
diff --git a/pyproject.toml b/pyproject.toml
index e7b2209..5e3bdb7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,6 +24,10 @@ dependencies = [
     # Modelli supportati e installati (aggiungere qui sotto quelli che si vogliono usare)
     "google-genai",
     "ollama",
+    "openai",
+    "mistralai",
+    "deepseek",
+    "xai",
 
     # API di exchange di criptovalute
     "coinbase-advanced-py",
diff --git a/src/app/configs.py b/src/app/configs.py
index 45b5b01..edd3e39 100644
--- a/src/app/configs.py
+++ b/src/app/configs.py
@@ -10,6 +10,10 @@ from agno.tools import Toolkit
 from agno.models.base import Model
 from agno.models.google import Gemini
 from agno.models.ollama import Ollama
+from agno.models.openai import OpenAIChat
+from agno.models.mistral import MistralChat
+from agno.models.deepseek import DeepSeek
+from agno.models.xai import xAI
 
 log = logging.getLogger(__name__)
 
@@ -19,7 +23,6 @@ class AppModel(BaseModel):
     name: str = "gemini-2.0-flash"
     label: str = "Gemini"
     model: type[Model] | None = None
-
     def get_model(self, instructions: str) -> Model:
         """
         Restituisce un'istanza del modello specificato.
@@ -54,22 +57,84 @@ class AppModel(BaseModel):
             output_schema=output_schema
         )
 
+
+
 class APIConfig(BaseModel):
     retry_attempts: int = 3
     retry_delay_seconds: int = 2
 
+
+
 class Strategy(BaseModel):
     name: str = "Conservative"
     label: str = "Conservative"
     description: str = "Focus on low-risk investments with steady returns."
 
+
+
 class ModelsConfig(BaseModel):
     gemini: list[AppModel] = [AppModel()]
+    gpt: list[AppModel] = [AppModel(name="gpt-4o", label="OpenAIChat")]
+    mistral: list[AppModel] = [AppModel(name="mistral-large-latest", label="Mistral")]
+    deepseek: list[AppModel] = [AppModel(name="deepseek-chat", label="DeepSeek")]
+    xai: list[AppModel] = [AppModel(name="grok-3", label="xAI")]
     ollama: list[AppModel] = []
 
     @property
     def all_models(self) -> list[AppModel]:
-        return self.gemini + self.ollama
+        return self.gemini + self.ollama + self.gpt + self.mistral + self.deepseek + self.xai
+
+    def validate_models(self) -> None:
+        """
+        Validate the configured models for each provider.
+        """
+        self.__validate_online_models(self.gemini, clazz=Gemini, key="GOOGLE_API_KEY")
+        self.__validate_online_models(self.gpt, clazz=OpenAIChat, key="OPENAI_API_KEY")
+        self.__validate_online_models(self.mistral, clazz=MistralChat, key="MISTRAL_API_KEY")
+        self.__validate_online_models(self.deepseek, clazz=DeepSeek, key="DEEPSEEK_API_KEY")
+        self.__validate_online_models(self.xai, clazz=xAI, key="XAI_API_KEY")
+
+        self.__validate_ollama_models()
+
+    def __validate_online_models(self, models: list[AppModel], clazz: type[Model], key: str | None = None) -> None:
+        """
+        Validate models for online providers like Gemini.
+        Args:
+            models: list of AppModel instances to validate
+            clazz: class of the model (e.g. Gemini)
+            key: API key required for the provider (optional)
+        """
+        if key and os.getenv(key) is None:
+            log.warning(f"No {key} set in environment variables for provider.")
+            models.clear()
+            return
+
+        for model in models:
+            model.model = clazz
+
+    def __validate_ollama_models(self) -> None:
+        """
+        Validate models for the Ollama provider.
+        """
+        try:
+            models_list = ollama.list()
+            availables = {model['model'] for model in models_list['models']}
+            not_availables: list[str] = []
+
+            for model in self.ollama:
+                if model.name in availables:
+                    model.model = Ollama
+                else:
+                    not_availables.append(model.name)
+            if not_availables:
+                log.warning(f"Ollama models not available: {not_availables}")
+
+            self.ollama = [model for model in self.ollama if model.model]
+
+        except Exception as e:
+            log.warning(f"Ollama is not running or not reachable: {e}")
+
+
 
 class AgentsConfigs(BaseModel):
     strategy: str = "Conservative"
@@ -118,7 +183,7 @@ class AppConfig(BaseModel):
 
         super().__init__(*args, **kwargs)
         self.set_logging_level()
-        self.validate_models()
+        self.models.validate_models()
         self._initialized = True
 
     def get_model_by_name(self, name: str) -> AppModel:
@@ -186,53 +251,3 @@ class AppConfig(BaseModel):
             logger = logging.getLogger(logger_name)
             logger.handlers.clear()
             logger.propagate = True
-
-    def validate_models(self) -> None:
-        """
-        Validate the configured models for each provider.
-        """
-        self.__validate_online_models("gemini", clazz=Gemini, key="GOOGLE_API_KEY")
-        self.__validate_ollama_models()
-
-    def __validate_online_models(self, provider: str, clazz: type[Model], key: str | None = None) -> None:
-        """
-        Validate models for online providers like Gemini.
-        Args:
-            provider: name of the provider (e.g. "gemini")
-            clazz: class of the model (e.g. Gemini)
-            key: API key required for the provider (optional)
-        """
-        if getattr(self.models, provider) is None:
-            log.warning(f"No models configured for provider '{provider}'.")
-
-        models: list[AppModel] = getattr(self.models, provider)
-        if key and os.getenv(key) is None:
-            log.warning(f"No {key} set in environment variables for {provider}.")
-            models.clear()
-            return
-
-        for model in models:
-            model.model = clazz
-
-    def __validate_ollama_models(self) -> None:
-        """
-        Validate models for the Ollama provider.
-        """
-        try:
-            models_list = ollama.list()
-            availables = {model['model'] for model in models_list['models']}
-            not_availables: list[str] = []
-
-            for model in self.models.ollama:
-                if model.name in availables:
-                    model.model = Ollama
-                else:
-                    not_availables.append(model.name)
-            if not_availables:
-                log.warning(f"Ollama models not available: {not_availables}")
-
-            self.models.ollama = [model for model in self.models.ollama if model.model]
-
-        except Exception as e:
-            log.warning(f"Ollama is not running or not reachable: {e}")
-
diff --git a/src/app/interface/chat.py b/src/app/interface/chat.py
index 150197b..37529f4 100644
--- a/src/app/interface/chat.py
+++ b/src/app/interface/chat.py
@@ -83,13 +83,15 @@ class ChatManager:
                     label="Modello da usare"
                 )
                 provider.change(fn=self.inputs.choose_team_leader, inputs=provider, outputs=None)
+                provider.value = self.inputs.team_leader_model.label
 
-                style = gr.Dropdown(
+                strategy = gr.Dropdown(
                     choices=self.inputs.list_strategies_names(),
                     type="index",
                     label="Stile di investimento"
                 )
-                style.change(fn=self.inputs.choose_strategy, inputs=style, outputs=None)
+                strategy.change(fn=self.inputs.choose_strategy, inputs=strategy, outputs=None)
+                strategy.value = self.inputs.strategy.label
 
             chat = gr.ChatInterface(
                 fn=self.gradio_respond
-- 
2.49.1