update analytics_tool.py, sentiment_tool.py and app.py

app.py

@@ -58,7 +58,7 @@ historical_agent = Agent(
     verbose=False,
     allow_delegations=True,
     tools=[historical_data_tool],
-    llm="gpt-4o"
+    llm="gpt-4o-mini"
 )
 
 analytics_agent = Agent(
@@ -71,7 +71,7 @@ analytics_agent = Agent(
     verbose=False,
     allow_delegations=False,
     tools=[analytics_tool],
-    llm="gpt-4o"
+    llm="gpt-4o-mini"
 )
 
 strategy_agent = Agent(

tools/analytics_tool.py

@@ -16,7 +16,7 @@ class AnalyticsTool(BaseTool):
     description: str = (
         "Aggregates structured market, historical, and sentiment data to produce "
         "quantitative indicators including pct_change, volatility, trend, sentiment, "
-        "alignment consistency, and a composite confidence score."
+        "sentiment_strength, confidence, alignment, and a composite score."
     )
     args_schema: Type[BaseModel] = AnalyticsInput
 
@@ -32,7 +32,6 @@ class AnalyticsTool(BaseTool):
             trend = historical_data.get("trend")
             sentiment = sentiment_data.get("sentiment")
 
-            # Validate required fields
             if price is None or pct_change is None or trend is None or sentiment is None:
                 return {
                     "error": (
@@ -44,37 +43,55 @@ class AnalyticsTool(BaseTool):
             sentiment = sentiment.lower()
 
             # ============================================================
-            # 2) Alignment logic
+            # 2) Sentiment strength & confidence (new)
             # ============================================================
 
-            aligned = (
-                (trend == "upward" and sentiment == "bullish") or
-                (trend == "downward" and sentiment == "bearish")
-            )
+            # Pull from SentimentTool if present
+            sentiment_strength = sentiment_data.get("sentiment_strength")
+            sentiment_confidence = sentiment_data.get("confidence")
+
+            # ---- Backwards-compatible defaults ----
+            if sentiment_strength is None:
+                sentiment_strength = {
+                    "bullish": 0.7,
+                    "neutral": 0.0,
+                    "bearish": -0.7
+                }.get(sentiment, 0.0)
+
+            if sentiment_confidence is None:
+                # Basic proxy confidence using number of headlines/comments
+                news_count = len(sentiment_data.get("news_headlines", []))
+                reddit_count = len(sentiment_data.get("reddit_comments", []))
+                sources = news_count + reddit_count
+                sentiment_confidence = min(1.0, 0.2 + 0.1 * sources)
+
+            # Effective weighted sentiment
+            effective_sentiment = sentiment_strength * sentiment_confidence
 
             # ============================================================
-            # 3) Composite score (bounded to [-1, 1])
+            # 3) Alignment logic (upgraded)
             # ============================================================
 
-            score = 0
-
-            # pct_change contribution
-            score += pct_change / 10  # scaled
+            aligned = (
+                (trend == "upward" and effective_sentiment > 0.2) or
+                (trend == "downward" and effective_sentiment < -0.2)
+            )
 
-            # alignment contribution
-            score += 0.2 if aligned else -0.2
+            # ============================================================
+            # 4) Composite score (new formula)
+            # ============================================================
 
-            # sentiment contribution
-            if sentiment == "bullish":
-                score += 0.1
-            elif sentiment == "bearish":
-                score -= 0.1
+            score = (
+                (pct_change / 10) +            # Trend effect
+                (effective_sentiment * 1.5) -  # Strong weight for sentiment
+                (volatility / 100 if volatility else 0)  # Penalize volatility
+            )
 
-            # Bound between -1 and 1
+            # Bound between [-1, 1]
             score = round(max(-1, min(1, score)), 2)
 
             # ============================================================
-            # 4) Final structured output
+            # 5) Final structured output
             # ============================================================
 
             return {
@@ -83,11 +100,17 @@ class AnalyticsTool(BaseTool):
                 "volatility_pct": volatility,
                 "trend": trend,
                 "sentiment": sentiment,
+                "sentiment_strength": round(sentiment_strength, 3),
+                "sentiment_confidence": round(sentiment_confidence, 3),
+                "effective_sentiment": round(effective_sentiment, 3),
                 "alignment": "aligned" if aligned else "divergent",
                 "composite_score": score,
                 "summary": (
-                    f"Trend={trend}, Sentiment={sentiment}, Alignment="
-                    f"{'aligned' if aligned else 'divergent'}, Score={score}"
+                    f"Trend={trend}, Sentiment={sentiment}, "
+                    f"Strength={round(sentiment_strength,3)}, "
+                    f"Confidence={round(sentiment_confidence,3)}, "
+                    f"Alignment={'aligned' if aligned else 'divergent'}, "
+                    f"Score={score}"
                 ),
             }
 

tools/sentiment_tool.py

@@ -1,14 +1,17 @@
+# tools/sentiment_tool.py
+
 import os
 import json
 import requests
-from typing import Type, List
+from typing import Type, List, Any, Dict, Optional
 
+from pydantic import BaseModel, Field
 from crewai.tools import BaseTool
 from openai import OpenAI
-from pydantic import BaseModel, Field
+
 
 # -----------------------------
-# Environment variables
+# Environment
 # -----------------------------
 SERPER_API_KEY = os.getenv("SERPER_API_KEY")
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
@@ -17,286 +20,204 @@ client = OpenAI(api_key=OPENAI_API_KEY)
 
 
 # -----------------------------
-# Input schema
+# Input Schema
 # -----------------------------
 class SentimentInput(BaseModel):
+    """Input schema for sentiment analysis tool."""
     query: str = Field(
         default="bitcoin",
-        description="Cryptocurrency name the user is asking about, e.g. 'bitcoin', 'ethereum', 'solana'."
+        description="Cryptocurrency or asset to evaluate sentiment for.",
     )
 
 
-# -----------------------------
-# Sentiment Tool
-# -----------------------------
+# ===================================================================
+#                  SENTIMENT TOOL (NEWS-ONLY VERSION)
+# ===================================================================
 class SentimentTool(BaseTool):
+    """
+    Fetches recent crypto news via Serper and produces aggregated sentiment
+    using GPT-4.1 with:
+        - sentiment: bullish / bearish / neutral
+        - sentiment_strength: float [-1, 1]
+        - confidence: float [0, 1]
+        - themes: emergent topics
+        - reasoning: summary explanation
+        - news_headlines: titles used
+    """
+
     name: str = "get_crypto_sentiment"
     description: str = (
-        "Fetches recent cryptocurrency news and Reddit discussions for a given coin, "
-        "then returns structured sentiment JSON based on Serper (Google News + "
-        "r/CryptoMarkets comments) and OpenAI analysis."
+        "Fetches crypto news via Serper and classifies sentiment with strength, "
+        "confidence, themes, and explanation. News-only version."
     )
-    # IMPORTANT: args_schema (not arg_schema) for Pydantic v2 + CrewAI
     args_schema: Type[BaseModel] = SentimentInput
 
-    # -----------------------------------------
-    # Helper: dynamic coin keywords via CoinGecko
-    # -----------------------------------------
-    def _coin_keywords(self, coin: str) -> List[str]:
-        """
-        Build a keyword set for matching Reddit comments:
-        - coin name
-        - no-space version
-        - CoinGecko ticker symbol (e.g. btc, eth, sol) when available
-        """
-        coin = coin.lower().strip()
-        keywords = set()
-
-        if not coin:
-            return ["bitcoin", "btc"]
-
-        # Base name variants
-        keywords.add(coin)                      # "bitcoin"
-        keywords.add(coin.replace(" ", ""))     # "shiba inu" -> "shibainu"
-        keywords.add(coin.split()[0])           # first word e.g. "shiba"
-        if len(coin) >= 3:
-            keywords.add(coin[:3])              # crude fallback, e.g. "bit"
-
-        # Try to get symbol from CoinGecko
-        try:
-            # First attempt: assume user input matches CoinGecko ID
-            cg_url = f"https://api.coingecko.com/api/v3/coins/{coin}"
-            r = requests.get(cg_url, timeout=5)
-            if r.status_code != 200:
-                # Fallback: use /search when ID doesn't match
-                search_url = "https://api.coingecko.com/api/v3/search"
-                sr = requests.get(search_url, params={"query": coin}, timeout=5)
-                if sr.status_code == 200:
-                    results = sr.json().get("coins", [])
-                    if results:
-                        first_id = results[0].get("id")
-                        if first_id:
-                            r = requests.get(
-                                f"https://api.coingecko.com/api/v3/coins/{first_id}",
-                                timeout=5
-                            )
-
-            if r.status_code == 200:
-                data = r.json()
-                symbol = data.get("symbol", "").lower()
-                if symbol:
-                    keywords.add(symbol)          # "btc"
-                    keywords.add(symbol.upper())  # "BTC"
-                    keywords.add(symbol + " price")
-                    keywords.add(coin + " price")
-        except Exception:
-            # If CoinGecko fails, we still have the base keywords
-            pass
-
-        return list({k for k in keywords if k})
-
-    # -----------------------------------------
-    # Helper: fetch recent news headlines
-    # -----------------------------------------
-    def _fetch_news(self, query: str) -> List[str]:
+    # -----------------------------------------------------
+    # Fetch news (Serper)
+    # -----------------------------------------------------
+    def _fetch_news(self, query: str, max_results: int = 12) -> (List[str], Optional[str]):
         if not SERPER_API_KEY:
-            return []
+            return [], "SERPER_API_KEY missing"
 
-        try:
-            url = "https://google.serper.dev/news"
-            headers = {
-                "X-API-KEY": SERPER_API_KEY,
-                "Content-Type": "application/json"
-            }
-            payload = {
-                "q": f"{query} crypto",
-                "num": 10
-            }
-
-            r = requests.post(url, headers=headers, json=payload, timeout=10)
-            r.raise_for_status()
-            news_items = r.json().get("news", [])
-            return [n.get("title", "").strip() for n in news_items[:10] if n.get("title")]
-        except Exception:
-            return []
-
-    # -----------------------------------------
-    # Helper: find recent r/CryptoMarkets posts (last 7 days)
-    # -----------------------------------------
-    def _fetch_reddit_post_urls(self, keywords: List[str]) -> List[str]:
-        """
-        Use Serper search to find r/CryptoMarkets/comments posts in the last 7 days
-        matching the coin keywords.
-        """
-        if not SERPER_API_KEY:
-            return []
+        url = "https://google.serper.dev/news"
+        headers = {"X-API-KEY": SERPER_API_KEY, "Content-Type": "application/json"}
+        payload = {"q": f"{query} cryptocurrency", "num": max_results}
 
         try:
-            query_string = " OR ".join(f'"{k}"' for k in keywords)
-            search_query = f"({query_string}) site:reddit.com/r/CryptoMarkets/comments"
+            resp = requests.post(url, headers=headers, json=payload, timeout=10)
+            resp.raise_for_status()
+            news_items = resp.json().get("news", []) or []
+            titles = [n.get("title", "").strip() for n in news_items if n.get("title")]
 
-            url = "https://google.serper.dev/search"
-            headers = {
-                "X-API-KEY": SERPER_API_KEY,
-                "Content-Type": "application/json"
-            }
-            payload = {
-                "q": search_query,
-                "num": 10,
-                "tbs": "qdr:w"  # last 7 days
-            }
+            # Deduplicate while preserving order
+            seen, unique = set(), []
+            for t in titles:
+                if t not in seen:
+                    seen.add(t)
+                    unique.append(t)
 
-            r = requests.post(url, headers=headers, json=payload, timeout=10)
-            r.raise_for_status()
-
-            organic_results = r.json().get("organic", [])
-            urls = [
-                item.get("link")
-                for item in organic_results
-                if "/comments/" in (item.get("link") or "")
-            ]
-            return [u for u in urls if u]
-        except Exception:
-            return []
-
-    # -----------------------------------------
-    # Helper: scrape Reddit comments from Serper
-    # -----------------------------------------
-    def _scrape_reddit_comments(self, urls: List[str], keywords: List[str]) -> List[str]:
-        """
-        Use Serper /scrape to pull text blocks from Reddit threads.
-        Keep only early blocks (top comments) that mention the coin keywords.
-        """
-        if not SERPER_API_KEY:
-            return []
+            return unique, None
 
-        comments: List[str] = []
+        except Exception as e:
+            return [], f"Serper error: {str(e)}"
 
-        for link in urls[:3]:  # limit to 3 threads for speed & cost
-            try:
-                url = "https://google.serper.dev/scrape"
-                headers = {
-                    "X-API-KEY": SERPER_API_KEY,
-                    "Content-Type": "application/json"
-                }
-                payload = {"url": link}
-
-                r = requests.post(url, headers=headers, json=payload, timeout=10)
-                r.raise_for_status()
-
-                blocks = r.json().get("blocks", [])
-                text_blocks = [b.get("text", "") for b in blocks[:20]]
-
-                for t in text_blocks:
-                    text = (t or "").strip()
-                    if not text:
-                        continue
-                    lower = text.lower()
-                    # basic relevance: contains any coin keyword and is not tiny
-                    if any(k.lower() in lower for k in keywords) and len(text) > 40:
-                        comments.append(text)
-
-            except Exception:
-                # Skip any failed scrape silently
-                continue
-
-        # Cap to 10 highest-signal comments
-        return comments[:10]
-
-    # -----------------------------------------
-    # Main execution
-    # -----------------------------------------
-    def _run(self, query: str = "bitcoin") -> dict:
-        """
-        End-to-end sentiment pipeline:
-        - Build coin keyword set (coin name + ticker via CoinGecko)
-        - Fetch Serper News for the coin
-        - Fetch r/CryptoMarkets posts in last 7 days and scrape comments
-        - Ask OpenAI (gpt-4.1) to return structured JSON sentiment.
-        """
-        if not OPENAI_API_KEY:
-            return {"error": "OPENAI_API_KEY missing in environment."}
-        if not SERPER_API_KEY:
+    # -----------------------------------------------------
+    # LLM Sentiment Aggregation
+    # -----------------------------------------------------
+    def _analyze_with_llm(self, coin: str, headlines: List[str]) -> Dict[str, Any]:
+
+        if not headlines:
             return {
-                "error": "SERPER_API_KEY missing in environment. "
-                         "Cannot fetch news/reddit sentiment."
+                "sentiment": "neutral",
+                "sentiment_strength": 0.0,
+                "confidence": 0.0,
+                "reasoning": "No news available; defaulting to neutral.",
+                "news_headlines": [],
+                "themes": []
             }
 
-        try:
-            coin = query.strip()
-            if not coin:
-                coin = "bitcoin"
-
-            # 1) Build keyword set (coin + ticker)
-            keywords = self._coin_keywords(coin)
-
-            # 2) Fetch news
-            news_headlines = self._fetch_news(coin)
-
-            # 3) Fetch & scrape Reddit comments
-            reddit_urls = self._fetch_reddit_post_urls(keywords)
-            reddit_comments = self._scrape_reddit_comments(reddit_urls, keywords)
-
-            # 4) Build combined context
-            combined_text = (
-                "NEWS HEADLINES:\n"
-                + ("\n".join(f"- {h}" for h in news_headlines) if news_headlines else "None")
-                + "\n\nREDDIT COMMENTS (r/CryptoMarkets):\n"
-                + ("\n".join(f"- {c}" for c in reddit_comments) if reddit_comments else "None")
-            )
+        headlines_block = "\n".join(f"{i+1}. {h}" for i, h in enumerate(headlines))
+
+        prompt = f"""
+You are a professional crypto macro-sentiment analyst.
 
-            # 5) Ask OpenAI for structured sentiment JSON
-            prompt = f"""
-You are a crypto sentiment analyst.
+Analyze the following recent news headlines about "{coin}" and determine
+aggregate sentiment.
 
-You are given recent NEWS HEADLINES and REDDIT COMMENTS about the coin "{coin}".
+Headlines:
+{headlines_block}
 
-Your job:
-1. Decide whether the overall sentiment is bullish, bearish, or neutral.
-2. Write a short reasoning explaining why, referencing both news and reddit if available.
-3. Return ONLY valid JSON in this exact format:
+Return STRICT JSON ONLY in this format:
 
 {{
   "sentiment": "bullish" | "bearish" | "neutral",
-  "reasoning": "short explanation tying together news + reddit, if both exist",
-  "news_headlines": [...],         // list of strings, may be empty
-  "reddit_comments": [...]         // list of strings, may be empty
+  "sentiment_strength": number,   // -1.0 to +1.0
+  "confidence": number,           // 0.0 to 1.0
+  "reasoning": "short explanation",
+  "news_headlines": [...],
+  "themes": [...]
 }}
 
-Do NOT wrap the JSON in backticks or any extra text.
-Just return the JSON object.
-
-DATA:
-{combined_text}
+Rules:
+- Consider macro context, price action, regulatory tone, adoption, and risk sentiment.
+- No extra text. JSON only.
 """
 
+        try:
             completion = client.chat.completions.create(
                 model="gpt-4.1",
                 temperature=0.2,
                 messages=[
-                    {"role": "system", "content": "You are a precise crypto sentiment classifier."},
-                    {"role": "user",   "content": prompt}
+                    {"role": "system", "content": "Return ONLY valid JSON. You are precise."},
+                    {"role": "user", "content": prompt}
                 ]
             )
 
-            raw_content = completion.choices[0].message.content.strip()
+            raw = completion.choices[0].message.content.strip()
 
-            # Try to parse JSON; if it fails, wrap raw content
+            # Attempt direct JSON load
             try:
-                parsed = json.loads(raw_content)
-                # Ensure we always attach raw data as well for downstream tools if needed
-                parsed.setdefault("news_headlines", news_headlines)
-                parsed.setdefault("reddit_comments", reddit_comments)
-                return parsed
-            except Exception:
-                # Fallback: return structured-ish dict with raw model output
-                return {
-                    "sentiment": None,
-                    "reasoning": "Model did not return valid JSON; raw content preserved.",
-                    "news_headlines": news_headlines,
-                    "reddit_comments": reddit_comments,
-                    "raw_model_output": raw_content,
-                }
+                parsed = json.loads(raw)
+            except:
+                # Try to extract JSON substring
+                start, end = raw.find("{"), raw.rfind("}")
+                if start == -1 or end == -1:
+                    raise ValueError("No JSON found in model output.")
+                parsed = json.loads(raw[start:end+1])
+
+            # Validate sentiment
+            sentiment = parsed.get("sentiment", "neutral").lower()
+            if sentiment not in {"bullish", "bearish", "neutral"}:
+                sentiment = "neutral"
+
+            # Clip strength + confidence
+            def clip(val, lo, hi, default):
+                try:
+                    v = float(val)
+                    return max(lo, min(hi, v))
+                except:
+                    return default
+
+            strength = clip(parsed.get("sentiment_strength"), -1.0, 1.0, 0.0)
+            confidence = clip(parsed.get("confidence"), 0.0, 1.0, 0.0)
+
+            themes = parsed.get("themes", [])
+            if not isinstance(themes, list):
+                themes = []
+
+            used = parsed.get("news_headlines", headlines)
+            if not isinstance(used, list) or not used:
+                used = headlines
+
+            return {
+                "sentiment": sentiment,
+                "sentiment_strength": strength,
+                "confidence": confidence,
+                "reasoning": parsed.get("reasoning", ""),
+                "news_headlines": used,
+                "themes": themes
+            }
 
         except Exception as e:
-            return {"error": f"SentimentTool failed: {str(e)}"}
+            return {
+                "sentiment": "neutral",
+                "sentiment_strength": 0.0,
+                "confidence": 0.0,
+                "reasoning": f"LLM sentiment failure: {str(e)}",
+                "news_headlines": headlines,
+                "themes": []
+            }
+
+    # -----------------------------------------------------
+    # Main Entrypoint
+    # -----------------------------------------------------
+    def _run(self, query: str = "bitcoin") -> Dict[str, Any]:
+
+        if not OPENAI_API_KEY:
+            return {
+                "sentiment": "neutral",
+                "sentiment_strength": 0.0,
+                "confidence": 0.0,
+                "reasoning": "OPENAI_API_KEY missing; neutral fallback.",
+                "news_headlines": [],
+                "themes": []
+            }
+
+        # Fetch news
+        headlines, news_error = self._fetch_news(query)
+
+        if news_error and not headlines:
+            return {
+                "sentiment": "neutral",
+                "sentiment_strength": 0.0,
+                "confidence": 0.0,
+                "reasoning": f"No news available: {news_error}",
+                "news_headlines": [],
+                "themes": []
+            }
+
+        # Analyze
+        sentiment = self._analyze_with_llm(query, headlines)
+
+        sentiment["news_error"] = news_error
+        return sentiment