Update tools, add __init__, update app.py

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -1,254 +1,248 @@
 # import libraries, APis and LLMs
 from crewai import Agent, Task, Crew
 import os
-from dotenv import load_dotenv
-from pathlib import Path
 from tools.market_data import MarketDataTool
 from tools.sentiment_tool import SentimentTool
 from tools.historical_data_tool import HistoricalDataTool
 from tools.analytics_tool import AnalyticsTool
-import json
 import gradio as gr
 import warnings
-import time
 
 warnings.filterwarnings("ignore")
 
-# Load environment variables (from local .env or Hugging Face secrets)
-load_dotenv()
-
+# ----------------------
+# ENVIRONMENT VARIABLES
+# ----------------------
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 SERPER_API_KEY = os.getenv("SERPER_API_KEY")
 
-# Optional: set CHROMA_OPENAI_API_KEY for embedding compatibility
-os.environ["CHROMA_OPENAI_API_KEY"] = OPENAI_API_KEY
-
-os.environ["OPENAI_MODEL_NAME"] = "gpt-5-mini"
+OPENAI_MODEL_NAME = "gpt-5-mini"
+os.environ["OPENAI_MODEL_NAME"] = OPENAI_MODEL_NAME
 
-#Tools
+# ----------------------
+# TOOLS (structured JSON)
+# ----------------------
 market_data_tool = MarketDataTool()
 sentiment_tool = SentimentTool()
-historical_data_tool= HistoricalDataTool()
+historical_data_tool = HistoricalDataTool()
 analytics_tool = AnalyticsTool()
 
+# ----------------------
+# AGENTS
+# ----------------------
 
-
-# Define the agents
 market_agent = Agent(
     role="Crypto Market Analyst",
-    goal="Fetches live market prices using the CoinGecko API and summarize trends.",
-    backstory="A data-driven analyst who monitors cryptocurrency movements"
-        "and provides concise and accurate market insights",
+    goal="Fetch live market price using CoinGecko and produce structured market JSON.",
+    backstory=(
+        "A disciplined market analyst who retrieves clean market data "
+        "including price and market liquidity."
+    ),
     verbose=False,
     allow_delegations=True,
-    tools = [market_data_tool]
+    tools=[market_data_tool],
+    llm=OPENAI_MODEL_NAME
 )
 
 sentiment_agent = Agent(
     role="Crypto Sentiment Analyst",
-    goal="Analyze public and media sentiment about cryptocurrencies to gauge market mood.",
-    backstory= "You are an expert at analyzing news headlines and social media chatter to assess whether sentiment is bullish or bearish.",
-    verbose = False,
+    goal="Analyze public sentiment on news & Reddit using Serper + OpenAI. Output structured sentiment JSON.",
+    backstory="An expert in NLP-based crypto sentiment interpretation.",
+    verbose=False,
     allow_delegations=True,
-    tools=[sentiment_tool]
+    tools=[sentiment_tool],
+    llm=OPENAI_MODEL_NAME
 )
 
 historical_agent = Agent(
     role="Crypto Historical Analyst",
-    goal="Analyze past cryptocurrency trends using historical data.",
-    backstory=(
-        "An experienced quantitative analyst who studies long-term "
-        "price behavior, volatility, and trend strength using CoinGecko data."
-    ),
-    verbose=True,
+    goal="Analyze long-term price trends, volatility, and movement patterns using clean structured JSON.",
+    backstory="A quantitative analyst specializing in historical trends.",
+    verbose=False,
     allow_delegations=True,
     tools=[historical_data_tool],
+    llm=OPENAI_MODEL_NAME
 )
 
 analytics_agent = Agent(
     role="Cryptocurrency Analytics",
-    goal="Integrate metrics from the market agent, historical agent, and sentiment agent"
-        "and anlyze them to devise a coherent market view.",
-    backstory=(
-        "You are an expert quantitative strategist who synthesizes trend, sentiment and volatility data"
-        "to produce both structured metrics and qualitative market insights."
+    goal=(
+        "Combine structured outputs from market, historical, and sentiment tools "
+        "into final analytics including trend, volatility, alignment, and composite scoring."
     ),
-    verbose=True,
+    backstory="A senior quant strategist synthesizing multiple signals into coherent analytics.",
+    verbose=False,
     allow_delegations=False,
-    tools=[analytics_tool]
+    tools=[analytics_tool],
+    llm=OPENAI_MODEL_NAME
 )
 
 strategy_agent = Agent(
     role="Crypto Strategy Analyst",
     goal=(
-        "Transform analytical metrics and sentiment data into an actionable trading plan. "
-        "Determine directional bias, entry/exit strategies, and risk management guidance "
-        "based on risk, opportunity, and sentiment metrics."
+        "Convert analytics into an actionable trading stance. Integrate sentiment, volatility, "
+        "risk, opportunity, and alignment to produce a structured trading strategy."
     ),
-    backstory=(
-        "A senior crypto strategist with a background in quantitative finance and "
-        "macro analysis. They integrate market structure, sentiment, and volatility "
-        "to form adaptive yet risk-aware trading stances."
-    ),
-    verbose=True,
+    backstory="A crypto strategist experienced in forming actionable plans.",
+    verbose=False,
+    llm=OPENAI_MODEL_NAME
 )
 
 reporting_agent = Agent(
     role="Crypto Reporting Analyst",
     goal=(
-        "Compile a concise, professional, and readable summary report "
-        "from all agents' outputs. The report should combine numerical analytics, "
-        "market context, sentiment, and trading strategy into one clear narrative."
+        "Generate a professionally formatted Markdown report synthesizing the full analysis."
     ),
-    backstory=(
-        "You are a senior market strategist and financial writer who creates daily reports "
-        "for traders and institutional clients. You blend analytical data, sentiment, "
-        "and technical insight into clear, actionable narratives."
-    ),
-    verbose=True,
+    backstory="A financial writer producing institutional-grade research.",
+    verbose=False,
+    llm=OPENAI_MODEL_NAME
 )
 
-# Define the tasks
+# ----------------------
+# TASKS
+# ----------------------
 
 market_data_task = Task(
-    description=("Retrieve the live market price for {cryptocurrency_selection} in {currency_selection} and summarize briefly"),
-    expected_output=("Summary of the {cryptocurrency_selection} price in {currency_selection}"),
-    agent=market_agent
+    description=(
+        "Use the market_data_tool to fetch the live market price for "
+        "{cryptocurrency_selection} in {currency_selection}. "
+        "Return structured JSON output only."
+    ),
+    expected_output="Structured JSON of current market metrics.",
+    agent=market_agent,
 )
 
 sentiment_task = Task(
-    description="Fetch sentiment for {cryptocurrency_selection} from Google News and Reddit, "
-    "then using expert intuition classify it as bullish, bearish or neutral.",
-    expected_output="Short summary with a sentiment classification.",
-    async_execution=True,
-    agent=sentiment_agent
+    description=(
+        "Fetch sentiment for {cryptocurrency_selection} using sentiment_tool. "
+        "Return structured JSON with sentiment, reasoning, and the raw headlines used."
+    ),
+    expected_output="Structured sentiment JSON (sentiment, reasoning, headlines).",
+    agent=sentiment_agent,
 )
 
 historical_data_task = Task(
-    description="Fetch and summarize {cryptocurrency_selection}'s {currency_selection} price trend over the past {days_selection} days.",
-    expected_output="A short summary including start price, end price, percent change, volatility, and trend direction.",
+    description=(
+        "Use the historical_data_tool to retrieve structured historical price data "
+        "for {cryptocurrency_selection} over {days_selection} days."
+    ),
+    expected_output=(
+        "Structured historical JSON with start_price, end_price, pct_change, "
+        "volatility_pct, and trend."
+    ),
     agent=historical_agent,
 )
 
 analytics_task = Task(
     description=(
-        "Combine the results of the Market, Historical and Sentiment agents for {cryptocurrency_selection}."
-        "First, use the 'analytics_tool' tool to compute structured metrics."
-        "Then, interpret those metrics into an analytical narrative summarizing the overall market condition, risks and opportunites for that cryptocurrency"
-    ),
-    expected_output=(
-        "A JSON object containing structured indicators from the tool"
-        "and an LLM-generated interpretation explaining what they mean."
+        "Use analytics_tool to combine market_data, historical_data, and sentiment_data "
+        "into final structured analytics including trend, volatility, sentiment, alignment, "
+        "and composite score."
     ),
+    expected_output="Structured analytics JSON.",
     agent=analytics_agent,
     inputs={
         "market_data": "{output_of_market_data_task}",
         "historical_data": "{output_of_historical_data_task}",
-        "sentiment_data": "{output_of_sentiment_data_task}"
+        "sentiment_data": "{output_of_sentiment_data_task}",
     }
 )
 
 strategy_task = Task(
     description=(
-        "Based on the structured analytics output for {cryptocurrency_selection}, "
-        "derive a clear trading stance. Evaluate the metrics such as sentiment_confidence, "
-        "risk_score_out_of_10, opportunity_score_out_of_10, volatility, and RSI. "
-        "Formulate an actionable trading bias (e.g., long, neutral, short) with reasoning. "
-        "Provide position size guidance, entry/exit levels, and a brief risk management plan."
-    ),
-    expected_output=(
-        "JSON object with fields: bias, position_size, entry_strategy, exit_strategy, "
-        "risk_management, and reasoning."
+        "Based on the structured analytics, produce an actionable trading stance "
+        "including: bias, strategy, risk guidance, and rationale."
     ),
+    expected_output="Structured strategy JSON.",
     agent=strategy_agent,
 )
 
 reporting_task = Task(
     description=(
-        "Generate a cohesive summary report for {cryptocurrency_selection}. "
-        "Combine data and insights from the Market, Historical, Sentiment, Analytics, "
-        "and Strategy agents. The report should read like a professional crypto analysis "
-        "briefing with structured Markdown sections."
-    ),
-    expected_output=(
-        "A Markdown-formatted report with sections:\n"
-        "1️⃣ Market Overview\n"
-        "2️⃣ Historical Performance\n"
-        "3️⃣ Sentiment Analysis\n"
-        "4️⃣ Analytical Summary\n"
-        "5️⃣ Strategy Outlook\n"
-        "6️⃣ Final Takeaways\n"
-        "Each section should contain concise, data-backed explanations and actionable insights."
+        "Create a well-formatted Markdown report combining all structured outputs: "
+        "Market, Historical, Sentiment, Analytics, and Strategy."
     ),
+    expected_output="Markdown-formatted final report.",
     agent=reporting_agent,
 )
 
-# Create a crew
+# ----------------------
+# CREW EXECUTION PIPELINE
+# ----------------------
+
 crypto_analysis_crew = Crew(
-    agents=[market_agent, historical_agent, sentiment_agent, analytics_agent, strategy_agent, reporting_agent],
-    tasks=[market_data_task, historical_data_task, sentiment_task, analytics_task, strategy_task, reporting_task],
-    process = "sequential",
+    agents=[
+        market_agent,
+        historical_agent,
+        sentiment_agent,
+        analytics_agent,
+        strategy_agent,
+        reporting_agent
+    ],
+    tasks=[
+        market_data_task,
+        historical_data_task,
+        sentiment_task,
+        analytics_task,
+        strategy_task,
+        reporting_task
+    ],
+    process="sequential",
     verbose=True
-    )
+)
+
+# ----------------------
+# GRADIO UI HANDLER
+# ----------------------
 
-# define the main gradio handler
 def generate_report(crypto_name, currency, days):
-    crypto_trading_inputs={
-    "cryptocurrency_selection": crypto_name.lower(),
-    "currency_selection": currency.lower(),
-    "days_selection": int(days),
+    crypto_inputs = {
+        "cryptocurrency_selection": crypto_name.lower(),
+        "currency_selection": currency.lower(),
+        "days_selection": int(days),
     }
 
-    result = crypto_analysis_crew.kickoff(inputs=crypto_trading_inputs)
-    
-    # Ensure Markdown rendering
+    result = crypto_analysis_crew.kickoff(inputs=crypto_inputs)
+
+    # Crew returns a dict with final_output
     if isinstance(result, dict) and "final_output" in result:
         return result["final_output"]
+
     return str(result)
 
-def analyze_crypto(crypto, currency, days):
-        yield "⏳ Starting analysis...", None
-        time.sleep(1)
-        yield "📊 Fetching live & historical market data...", None
-        time.sleep(1)
-        yield "🧠 Running multi-agent reasoning (market, sentiment, history)...", None
-        report = generate_report(crypto, currency, days)
-        yield "✅ Analysis Complete!", report
+# ----------------------
+# GRADIO APP
+# ----------------------
 
-#Gradio interface
 with gr.Blocks(theme=gr.themes.Monochrome()) as app:
     gr.Markdown("# 🪙 Crypto Intelligence Dashboard")
-    gr.Markdown("Run a full multi-agent analysis with adjustable lookback period.")
+    gr.Markdown("Run a full multi-agent crypto analysis using structured JSON tools.")
 
     with gr.Row():
         crypto = gr.Textbox(
-            label="Enter Cryptocurrency Name (e.g bitcoin, ethereum, cardano)",
-            placeholder="Type any crytocurrency name...",
+            label="Cryptocurrency (e.g. bitcoin, ethereum)",
+            placeholder="Type cryptocurrency name...",
             value="bitcoin"
         )
         currency = gr.Dropdown(
             ["usd", "eur", "gbp"],
-            label="Select Currency",
+            label="Currency",
             value="usd"
         )
         days = gr.Slider(
-            30, 730, value=365, step=15,
-            label="Days to analyze (Historical Range)"
+            minimum=30, maximum=730, value=365, step=15,
+            label="Historical Lookback (days)"
         )
 
     run_button = gr.Button("🚀 Run Full Analysis", variant="primary")
-
-    # Add a simple status box to show "Complete!" text
-    status_box = gr.Markdown("💤 Idle")
-
     report_output = gr.Markdown(label="📊 Intelligence Report")
 
     run_button.click(
-    analyze_crypto,
-    inputs=[crypto, currency, days],
-    outputs=[status_box, report_output],
-    show_progress=True  
+        generate_report,
+        inputs=[crypto, currency, days],
+        outputs=report_output,
+        show_progress=True  
     )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860, share=True)
+    app.launch(server_name="0.0.0.0", server_port=7860)

tools/analytics_tool.py

@@ -1,54 +1,94 @@
-from crewai_tools import RagTool
-import json
-
-class AnalyticsTool(RagTool):
-    name: str = "analytics_tool"
-    description: str = (
-        "Processes and aggregates outputs from market, historical and sentiment agents"
-         "to generate structured indicators and performance metrics, giving a holistic view of the cryptocurrency's condition."
-    )
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+# ---------- Input Schema ----------
+class AnalyticsInput(BaseModel):
+    market_data: dict = Field(..., description="Structured JSON from MarketDataTool")
+    historical_data: dict = Field(..., description="Structured JSON from HistoricalDataTool")
+    sentiment_data: dict = Field(..., description="Structured JSON from SentimentTool")
 
-    def _run(self, market_data: dict, historical_data: dict, sentiment_data: dict):
-        # combine results from the other agents into structured numeric metrics
 
+# ---------- Tool ----------
+class AnalyticsTool(BaseTool):
+    name = "analytics_tool"
+    description = (
+        "Aggregates structured market, historical, and sentiment data to produce "
+        "quantitative indicators including pct_change, volatility, trend, sentiment, "
+        "alignment consistency, and a composite confidence score."
+    )
+    args_schema = AnalyticsInput
+
+    def _run(self, market_data: dict, historical_data: dict, sentiment_data: dict) -> dict:
         try:
-            #Normalize strings -> dicts
-            if isinstance(market_data, str):
-                market_data = json.loads(market_data)
-            if isinstance(historical_data, str):
-                historical_data = json.loads(historical_data)
-            if isinstance(sentiment_data, str):
-                sentiment_data = json.loads(sentiment_data)
-
-            #Extract info safely
-            current_price = market_data.get("price") or market_data.get("latest_price")
-            pct_change = historical_data.get("pct_change", 0)
-            volatility = historical_data.get("volatility_pct", 0)
-            trend = historical_data.get("trend", "unknown")
-            sentiment = sentiment_data.get("final_sentiment_classification", "neutral")
-
-            #Compute basic consistency logic
+            # ============================================================
+            # 1) Extract fields safely from structured tool outputs
+            # ============================================================
+
+            price = market_data.get("latest_price")
+            pct_change = historical_data.get("pct_change")
+            volatility = historical_data.get("volatility_pct")
+            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": (
+                        "Missing required fields in analytics input. "
+                        "Ensure all tools returned structured JSON."
+                    )
+                }
+
+            sentiment = sentiment.lower()
+
+            # ============================================================
+            # 2) Alignment logic
+            # ============================================================
+
             aligned = (
-                (trend == "upward" and "bullish" in sentiment.lower()) or
-                (trend == "downward" and "bearish" in sentiment.lower())
+                (trend == "upward" and sentiment == "bullish") or
+                (trend == "downward" and sentiment == "bearish")
             )
 
-            score = (
-                (pct_change/10) + (0.2 if aligned else -0.2)
-                + (0.1 if "bullish" in sentiment.lower() else -0.1 if "bearish" in sentiment.lower() else 0)
-            )
+            # ============================================================
+            # 3) Composite score (bounded to [-1, 1])
+            # ============================================================
+
+            score = 0
+
+            # pct_change contribution
+            score += pct_change / 10  # scaled
 
+            # alignment contribution
+            score += 0.2 if aligned else -0.2
+
+            # sentiment contribution
+            if sentiment == "bullish":
+                score += 0.1
+            elif sentiment == "bearish":
+                score -= 0.1
+
+            # Bound between -1 and 1
             score = round(max(-1, min(1, score)), 2)
 
+            # ============================================================
+            # 4) Final structured output
+            # ============================================================
+
             return {
-                "price": current_price,
+                "price": price,
                 "pct_change": pct_change,
-                "volatility": volatility,
+                "volatility_pct": volatility,
                 "trend": trend,
                 "sentiment": sentiment,
                 "alignment": "aligned" if aligned else "divergent",
                 "composite_score": score,
-                "summary": f"Trend={trend}, Sentiment={sentiment}, Alignment={'aligned' if aligned else 'divergent'}, Score = {score}"
+                "summary": (
+                    f"Trend={trend}, Sentiment={sentiment}, Alignment="
+                    f"{'aligned' if aligned else 'divergent'}, Score={score}"
+                ),
             }
+
         except Exception as e:
             return {"error": f"AnalyticsTool failed: {str(e)}"}

tools/historical_data_tool.py

@@ -1,21 +1,27 @@
-# tools/historical_data_tool.py
-from crewai_tools import RagTool
 import requests
-from datetime import datetime
 import statistics
+from datetime import datetime
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+# ---------- Input Schema ----------
+class HistoricalInput(BaseModel):
+    symbol: str = Field(..., description="Cryptocurrency ID used by CoinGecko, e.g. 'bitcoin'")
+    currency: str = Field(default="usd", description="Fiat currency, e.g., 'usd'")
+    days: int = Field(..., description="Number of past days to retrieve (e.g., 30, 90, 365)")
+
 
-class HistoricalDataTool(RagTool):
-    name: str = "get_historical_data"
-    description: str = (
-        "Fetches and analyzes historical cryptocurrency market data "
-        "from the CoinGecko API for trend insights."
+# ---------- Tool ----------
+class HistoricalDataTool(BaseTool):
+    name = "get_historical_data"
+    description = (
+        "Fetches historical cryptocurrency market data from CoinGecko and computes "
+        "trend, percent change, and volatility. Returns structured JSON."
     )
+    args_schema = HistoricalInput
 
     def _run(self, symbol: str = "bitcoin", currency: str = "usd", days: int = 30) -> dict:
-        """
-        Fetch historical data for the specified cryptocurrency over a given number of days.
-        Computes basic trend and volatility statistics.
-        """
         url = f"https://api.coingecko.com/api/v3/coins/{symbol}/market_chart"
         params = {"vs_currency": currency, "days": days}
 
@@ -26,35 +32,57 @@ class HistoricalDataTool(RagTool):
 
             prices = data.get("prices", [])
             if not prices:
-                return {"error": f"No data found for {symbol}."}
+                return {"error": f"No historical data found for '{symbol}'."}
 
-            # Extract date and price
+            # -------- Extract date + price history --------
             history = [
-                {"date": datetime.utcfromtimestamp(p[0] / 1000).strftime("%Y-%m-%d"), "price": p[1]}
+                {
+                    "date": datetime.utcfromtimestamp(p[0] / 1000).strftime("%Y-%m-%d"),
+                    "price": float(p[1])
+                }
                 for p in prices
             ]
 
-            # Calculate simple stats
-            first, last = history[0]["price"], history[-1]["price"]
-            pct_change = ((last - first) / first) * 100
+            if len(history) < 2:
+                return {"error": "Insufficient historical data for volatility or trend analysis."}
+
+            start_price = history[0]["price"]
+            end_price = history[-1]["price"]
+
+            # -------- Percent Change --------
+            pct_change = ((end_price - start_price) / start_price) * 100
+
+            # -------- Daily Returns + Volatility --------
             daily_returns = [
                 (history[i + 1]["price"] - history[i]["price"]) / history[i]["price"]
                 for i in range(len(history) - 1)
             ]
-            volatility = statistics.stdev(daily_returns) * 100 if len(daily_returns) > 1 else 0
 
-            trend = "upward" if pct_change > 0 else "downward" if pct_change < 0 else "sideways"
+            volatility = (
+                statistics.stdev(daily_returns) * 100
+                if len(daily_returns) > 1
+                else 0
+            )
+
+            # -------- Trend Classification --------
+            if pct_change > 1.5:
+                trend = "upward"
+            elif pct_change < -1.5:
+                trend = "downward"
+            else:
+                trend = "sideways"
 
             return {
                 "symbol": symbol,
                 "currency": currency,
                 "days": days,
-                "start_price": round(first, 2),
-                "end_price": round(last, 2),
+                "start_price": round(start_price, 2),
+                "end_price": round(end_price, 2),
                 "pct_change": round(pct_change, 2),
                 "volatility_pct": round(volatility, 2),
                 "trend": trend,
+                "price_history": history,  # optional but useful for advanced analytics
             }
 
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": f"HistoricalDataTool failed: {str(e)}"}

tools/market_data.py

@@ -1,31 +1,63 @@
-import os
-from crewai_tools import RagTool
 import requests
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
 
-class MarketDataTool(RagTool):
-    name: str ="get_market_data"
-    description: str ="Fetches the current market price of a cryptocurrency in a chosen fiat currency using the CoinGecko API."
 
-    def _run(self, symbol="bitcoin", currency="usd"):
-        url = f"https://api.coingecko.com/api/v3/simple/price?ids={symbol}&vs_currencies={currency}"
+# ---------- Input Schema ----------
+class MarketDataInput(BaseModel):
+    symbol: str = Field(..., description="Cryptocurrency ID in CoinGecko format, e.g., 'bitcoin'")
+    currency: str = Field(default="usd", description="Fiat currency, e.g., 'usd', 'eur', 'gbp'")
+
+
+# ---------- Tool ----------
+class MarketDataTool(BaseTool):
+    name = "get_market_data"
+    description = (
+        "Fetches structured market data for a cryptocurrency including price and 24h volume "
+        "using the CoinGecko API."
+    )
+    args_schema = MarketDataInput
+
+    def _run(self, symbol: str = "bitcoin", currency: str = "usd") -> dict:
+        """
+        Returns structured JSON:
+        {
+            "symbol": "bitcoin",
+            "currency": "usd",
+            "latest_price": 90482,
+            "volume_24h": 38500000000
+        }
+        """
+
+        url = (
+            f"https://api.coingecko.com/api/v3/simple/price"
+            f"?ids={symbol}"
+            f"&vs_currencies={currency}"
+            f"&include_24hr_vol=true"
+        )
+
         try:
             response = requests.get(url, timeout=10)
             response.raise_for_status()
             data = response.json()
-            price = data.get(symbol, {}).get(currency)
+
+            asset = data.get(symbol, {})
+            price = asset.get(currency)
+            volume = asset.get(f"{currency}_24h_vol")
+
             if price is None:
                 return {
                     "symbol": symbol,
                     "currency": currency,
-                    "error": f"Could not find data for {symbol.upper()} in {currency.upper()}."
+                    "error": f"MarketDataTool: No price found for {symbol.upper()} in {currency.upper()}."
                 }
+
             return {
                 "symbol": symbol,
                 "currency": currency,
                 "latest_price": price,
-                "formatted": f"{symbol.capitalize()} price: {price} {currency.upper()}"
+                "volume_24h": volume,
             }
-        except Exception as e:
-            return {"error": str(e)}
-
 
+        except Exception as e:
+            return {"error": f"MarketDataTool failed: {str(e)}"}

tools/sentiment_tool.py

@@ -1,21 +1,14 @@
 import os
 import requests
-from crewai_tools import RagTool
+from crewai.tools import BaseTool
 from openai import OpenAI
-from pathlib import Path
-from dotenv import load_dotenv
 
-env_path = Path("/Users/clydecossey/Documents/Python/Crypto_Analysis_Agent/Open_AI.env")
-load_dotenv(dotenv_path=env_path)
+SERPER_API_KEY = os.getenv(key="SERPER_API_KEY")
 OPENAI_API_KEY = os.getenv(key = "OPENAI_API_KEY")
 
 client = OpenAI(api_key=OPENAI_API_KEY)
 
-serper_env_path = Path("Users/clydecossey/Documents/Python/Crypto_Analysis_Agent/Serper.env")
-load_dotenv(dotenv_path=serper_env_path)
-SERPER_API_KEY = os.getenv(key="SERPER_API_KEY")
-
-class SentimentTool(RagTool):
+class SentimentTool(BaseTool):
     name: str = "get_crypto_sentiment"
     description: str = (
         "Fetches recent cryptocurrency news and Reddit discussions,"
@@ -25,19 +18,29 @@ class SentimentTool(RagTool):
     def _run(self, query: str = "bitcoin") -> str:
         try:
             #Google news sentiment
-            news_url = "https://google.serper.dev/news"
-            headers = {"X-API-KEY": SERPER_API_KEY, "Content-Type": "application/json"}
-            payload = {"q": f"{query} crypto", "num": 5}
-            news_response = requests.post(news_url, headers=headers, json=payload, timout=10)
-            news = news_response.json().get("news", [])
-            headlines = [n["title"] for n in news[:5]]
-
+            headlines = []
+            try: 
+                news_url = "https://google.serper.dev/news"
+                headers = {"X-API-KEY": SERPER_API_KEY, "Content-Type": "application/json"}
+                payload = {"q": f"{query} crypto", "num": 5}
+                news_response = requests.post(news_url, headers=headers, json=payload, timeout=10)
+                news_response.raise_for_status()
+                news = news_response.json().get("news", [])
+                headlines = [n["title"] for n in news[:5]]
+            except:
+                pass # silent fail
+            
             #Reddit sentiment
-            reddit_url = f"https://www.reddit.com/search.json?q={query}&sort=new&limit=5"
-            reddit_headers = {"User-Agent": "CryptoAgent/1.0"}
-            reddit_response = requests.get(reddit_url,headers=reddit_headers, timeout=10)
-            reddit_posts = reddit_response.json().get("data", {}).get("children", [])
-            reddit_titles = [p["data"]["title"] for p in reddit_posts[:5]]
+            reddit_titles = []
+            try:
+                reddit_url = f"https://www.reddit.com/search.json?q={query}&sort=new&limit=5"
+                reddit_headers = {"User-Agent": "CryptoAgent/1.0"}
+                reddit_response = requests.get(reddit_url,headers=reddit_headers, timeout=10)
+                reddit_response.raise_for_status()
+                reddit_posts = reddit_response.json().get("data", {}).get("children", [])
+                reddit_titles = [p["data"]["title"] for p in reddit_posts[:5]]
+            except:
+                pass #silent fail
 
             combined_text = "News: " + " | ".join(headlines) + "\nReddit: " + " | ".join(reddit_titles)
 
@@ -61,5 +64,4 @@ You are a crypto sentiment analyst. Based on the following headlines and Reddit
             return sentiment_result
         
         except Exception as e:
-            return f"Error fetching sentiment data: {str(e)}"
-            
+            return f"Error fetching sentiment data: {str(e)}"