Upload chatbot.py with huggingface_hub

chatbot.py

@@ -1,302 +1,53 @@
 """
-Chatbot engine with RAG pipeline and proactive/reactive logic.
-Adapted for the AI Trading Experiment with parameter-aware responses.
-
-Supports multiple LLM providers:
-- HuggingFace Inference API (free tier available)
-- DeepSeek API
-- Fallback rule-based responses
+Chatbot engine with RAG pipeline for the AI Trading Experiment.
+Uses HuggingFace Inference API.
 """
 
 import os
 import sys
 import random
-import requests
-from typing import Optional, List, Tuple, Dict, Any
+from typing import Optional, List, Tuple
 from dataclasses import dataclass
-from enum import Enum
 
-# Attempt pysqlite3 workaround for HF Spaces
+# pysqlite3 workaround for HF Spaces
 try:
     __import__('pysqlite3')
     sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
 except ImportError:
-    pass  # Not in HF Spaces, use default sqlite3
+    pass
 
-# LangChain imports - using langchain_community for newer versions
 from langchain_community.document_loaders import TextLoader
 from langchain_community.vectorstores import Chroma
 from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain_text_splitters import CharacterTextSplitter
-from langchain_core.language_models.llms import LLM
+from huggingface_hub import InferenceClient
 
 from config import Scenario, ResearcherControlledParams, ParticipantVisibleParams
 
 
-# Configuration
 KNOWLEDGE_BASE_DIR = "knowledge_base"
 VECTOR_DB_DIR = "db/vectorstore"
+MODEL = "HuggingFaceH4/zephyr-7b-beta"
 
 
-class LLMProvider(Enum):
-    """Available LLM providers."""
-    HUGGINGFACE = "huggingface"
-    DEEPSEEK = "deepseek"
-    FALLBACK = "fallback"
-
-
-# ==================== LLM Provider Selection ====================
-
-# Check which API keys are available and select provider
-def get_llm_provider() -> LLMProvider:
-    """Determine which LLM provider to use based on available credentials."""
-    if os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HF_API_KEY"):
-        return LLMProvider.HUGGINGFACE
-    elif os.getenv("DEEPSEEK_API_KEY"):
-        return LLMProvider.DEEPSEEK
-    else:
-        print("Warning: No LLM API key found. Using fallback responses.")
-        print("Set HF_TOKEN for HuggingFace or DEEPSEEK_API_KEY for DeepSeek.")
-        return LLMProvider.FALLBACK
-
-
-# ==================== HuggingFace LLM ====================
-
-# Recommended free/cheap models (smallest to largest):
-# - "microsoft/Phi-3-mini-4k-instruct"     # 3.8B params, very fast
-# - "Qwen/Qwen2-1.5B-Instruct"             # 1.5B params, smallest
-# - "HuggingFaceH4/zephyr-7b-beta"         # 7B params, good quality
-# - "mistralai/Mistral-7B-Instruct-v0.2"   # 7B params, popular
-# - "meta-llama/Llama-2-7b-chat-hf"        # 7B params, requires approval
-
-DEFAULT_HF_MODEL = "HuggingFaceH4/zephyr-7b-beta"
-
-
-class HuggingFaceLLM(LLM):
-    """LLM wrapper for HuggingFace Inference API (free tier available)."""
-    api_key: str = ""
-    model_id: str = DEFAULT_HF_MODEL
-    temperature: float = 0.7
-    max_tokens: int = 512
-
-    def __init__(self, model_id: str = None, **kwargs):
-        super().__init__(**kwargs)
-        # Try multiple possible env var names
-        self.api_key = (
-            os.getenv("HF_TOKEN") or
-            os.getenv("HUGGINGFACE_TOKEN") or
-            os.getenv("HF_API_KEY") or
-            ""
-        )
-        if model_id:
-            self.model_id = model_id
-
-        if self.api_key:
-            print(f"Using HuggingFace model: {self.model_id}")
-        else:
-            print("Warning: No HuggingFace token found.")
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
-        if not self.api_key:
-            return self._fallback_response(prompt)
-
-        # HuggingFace Inference API endpoint
-        api_url = f"https://api-inference.huggingface.co/models/{self.model_id}"
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-
-        # Format prompt for instruction-tuned models
-        formatted_prompt = f"""<|system|>
-You are an AI trading advisor in the TradeVerse financial ecosystem. Provide helpful, concise advice.</s>
-<|user|>
-{prompt}</s>
-<|assistant|>
-"""
-
-        payload = {
-            "inputs": formatted_prompt,
-            "parameters": {
-                "max_new_tokens": self.max_tokens,
-                "temperature": self.temperature,
-                "do_sample": True,
-                "return_full_text": False
-            }
-        }
-
-        try:
-            response = requests.post(api_url, headers=headers, json=payload, timeout=60)
-
-            # Handle model loading (HF free tier may need to load model)
-            if response.status_code == 503:
-                data = response.json()
-                wait_time = data.get("estimated_time", 20)
-                print(f"Model loading, waiting {wait_time}s...")
-                import time
-                time.sleep(min(wait_time, 30))
-                response = requests.post(api_url, headers=headers, json=payload, timeout=60)
-
-            response.raise_for_status()
-            data = response.json()
-
-            # Handle different response formats
-            if isinstance(data, list) and len(data) > 0:
-                return data[0].get("generated_text", "").strip()
-            elif isinstance(data, dict):
-                return data.get("generated_text", "").strip()
-
-            return self._fallback_response(prompt)
-
-        except Exception as e:
-            print(f"HuggingFace API error: {e}")
-            return self._fallback_response(prompt)
-
-    def _fallback_response(self, prompt: str) -> str:
-        """Generate a basic response when API is unavailable."""
-        return FallbackLLM()._call(prompt)
-
-    @property
-    def _llm_type(self) -> str:
-        return "huggingface_inference"
-
-
-# ==================== DeepSeek LLM ====================
-
-DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"
-
-
-class DeepSeekLLM(LLM):
-    """LLM wrapper for DeepSeek API."""
-    api_key: str = ""
-    temperature: float = 0.7
-    max_tokens: int = 512
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.api_key = os.getenv("DEEPSEEK_API_KEY", "")
-        if self.api_key:
-            print("Using DeepSeek API")
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
-        if not self.api_key:
-            return FallbackLLM()._call(prompt)
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-        payload = {
-            "model": "deepseek-chat",
-            "messages": [
-                {"role": "system", "content": "You are an AI trading advisor in the TradeVerse financial ecosystem."},
-                {"role": "user", "content": prompt}
-            ],
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens
-        }
-
-        try:
-            response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
-            response.raise_for_status()
-            data = response.json()
-            return data["choices"][0]["message"]["content"].strip()
-        except Exception as e:
-            print(f"DeepSeek API error: {e}")
-            return FallbackLLM()._call(prompt)
-
-    @property
-    def _llm_type(self) -> str:
-        return "deepseek_api"
-
-
-# ==================== Fallback LLM (Rule-based) ====================
-
-class FallbackLLM(LLM):
-    """
-    Rule-based fallback when no API is available.
-    Generates responses based on scenario context and parameters.
-    """
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
-        """Generate a context-aware response without an LLM."""
-        prompt_lower = prompt.lower()
-
-        # Detect recommendation requests
-        if "buy" in prompt_lower and "recommend" in prompt_lower:
-            return self._generate_buy_response(prompt)
-        elif "sell" in prompt_lower and "recommend" in prompt_lower:
-            return self._generate_sell_response(prompt)
-        elif "hold" in prompt_lower and "recommend" in prompt_lower:
-            return self._generate_hold_response(prompt)
-
-        # Detect question types
-        if "risk" in prompt_lower:
-            return "When evaluating risk, consider the company's debt levels, market volatility, and any red flags like insider selling or unusual trading volume. The current scenario presents factors that warrant careful consideration."
-
-        if "insider" in prompt_lower or "trading volume" in prompt_lower:
-            return "Unusual insider activity or trading volume can signal that informed parties have information not yet public. This is often a warning sign that warrants caution."
-
-        if "sector" in prompt_lower or "industry" in prompt_lower:
-            return "Sector trends significantly impact individual companies. Consider broader market conditions, regulatory environment, and competitive dynamics when making your decision."
-
-        # Default analytical response
-        return "Based on the available information, I'd encourage you to weigh the key factors mentioned in the scenario. Consider both the potential opportunities and the risk factors before making your decision."
-
-    def _generate_buy_response(self, prompt: str) -> str:
-        return "Based on my analysis, buying could be appropriate here. The positive signals suggest potential upside, though you should consider your risk tolerance and the size of your position carefully."
-
-    def _generate_sell_response(self, prompt: str) -> str:
-        return "Based on my analysis, selling may be prudent. The risk factors present suggest potential downside that could outweigh staying invested. Consider protecting your capital."
-
-    def _generate_hold_response(self, prompt: str) -> str:
-        return "Based on my analysis, holding your position seems reasonable. The situation shows mixed signals, and waiting for more clarity before acting could be the wisest approach."
-
-    @property
-    def _llm_type(self) -> str:
-        return "fallback_rules"
-
-
-# ==================== LLM Factory ====================
-
-def create_llm(provider: LLMProvider = None, model_id: str = None) -> LLM:
-    """Factory function to create the appropriate LLM instance."""
-    if provider is None:
-        provider = get_llm_provider()
-
-    if provider == LLMProvider.HUGGINGFACE:
-        return HuggingFaceLLM(model_id=model_id)
-    elif provider == LLMProvider.DEEPSEEK:
-        return DeepSeekLLM()
-    else:
-        return FallbackLLM()
-
-
-# ==================== Chat Response ====================
-
 @dataclass
 class ChatResponse:
     """Response from the chatbot."""
     message: str
     is_proactive: bool
-    confidence_level: str  # "low", "medium", "high"
+    confidence_level: str
     sources_used: List[str]
 
 
-# ==================== Trading Chatbot ====================
-
 class TradingChatbot:
-    """
-    AI Chatbot for the trading experiment.
-    Supports both proactive advice and reactive queries.
-    """
+    """AI Chatbot for the trading experiment."""
 
-    def __init__(self, llm_provider: LLMProvider = None, model_id: str = None):
-        self.llm = create_llm(llm_provider, model_id)
+    def __init__(self):
+        self.client = InferenceClient(token=os.getenv("HF_TOKEN"))
         self.vectorstore = None
         self.chat_history: List[Tuple[str, str]] = []
         self._initialize_knowledge_base()
+        print(f"Using model: {MODEL}")
 
     def _initialize_knowledge_base(self):
         """Load and index the knowledge base documents."""
@@ -316,14 +67,12 @@ class TradingChatbot:
             print("Warning: No knowledge base documents found.")
             return
 
-        # Split documents into chunks
         splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
         split_docs = splitter.split_documents(docs)
 
         texts = [doc.page_content for doc in split_docs]
         metadatas = [{"source": doc.metadata.get("source", "unknown")} for doc in split_docs]
 
-        # Create embeddings and vectorstore
         try:
             embedding_function = HuggingFaceEmbeddings(
                 model_name="sentence-transformers/all-MiniLM-L6-v2"
@@ -340,62 +89,64 @@ class TradingChatbot:
         except Exception as e:
             print(f"Error initializing vectorstore: {e}")
 
-    def _get_confidence_framing(self, level: int) -> Dict[str, str]:
+    def _call_llm(self, prompt: str) -> str:
+        """Call the HuggingFace model."""
+        try:
+            messages = [
+                {"role": "system", "content": "You are an AI trading advisor in the TradeVerse financial ecosystem."},
+                {"role": "user", "content": prompt}
+            ]
+            response = self.client.chat_completion(
+                model=MODEL,
+                messages=messages,
+                max_tokens=512,
+                temperature=0.7
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"LLM error: {e}")
+            return "I'm having trouble processing that request. Please try again."
+
+    def _get_confidence_framing(self, level: int) -> dict:
         """Get language framing based on confidence parameter."""
         if level < 34:
-            return {
-                "prefix": "Based on the available information, one possibility is that",
-                "verb": "might consider",
-                "qualifier": "though there is considerable uncertainty",
-                "level": "low"
-            }
+            return {"prefix": "Based on the available information,", "verb": "might consider", "qualifier": "though there is uncertainty", "level": "low"}
         elif level < 67:
-            return {
-                "prefix": "Looking at the situation,",
-                "verb": "suggests",
-                "qualifier": "while noting some risk factors",
-                "level": "medium"
-            }
+            return {"prefix": "Looking at the situation,", "verb": "suggests", "qualifier": "while noting some risk factors", "level": "medium"}
         else:
-            return {
-                "prefix": "Based on my analysis,",
-                "verb": "strongly recommend",
-                "qualifier": "with high confidence",
-                "level": "high"
-            }
+            return {"prefix": "Based on my analysis,", "verb": "strongly recommend", "qualifier": "with high confidence", "level": "high"}
 
     def _get_depth_instructions(self, level: int) -> str:
-        """Get explanation depth instructions based on parameter."""
+        """Get explanation depth instructions."""
         if level < 34:
-            return "Provide a very brief response (1-2 sentences maximum). Focus only on the key point."
+            return "Provide a brief response (1-2 sentences)."
         elif level < 67:
-            return "Provide a moderate explanation (3-4 sentences). Include the main reasoning and key factors."
+            return "Provide a moderate explanation (3-4 sentences)."
         else:
-            return "Provide a detailed analysis. Cover all relevant factors, risks, and opportunities comprehensively."
+            return "Provide a detailed analysis covering all relevant factors."
 
     def _get_risk_framing(self, level: int) -> str:
-        """Get risk perspective based on parameter."""
+        """Get risk perspective."""
         if level < 34:
-            return "Emphasize potential risks and downside scenarios. Favor capital preservation over potential gains."
+            return "Emphasize potential risks. Favor capital preservation."
         elif level < 67:
-            return "Balance potential risks and opportunities. Present a measured risk-reward analysis."
+            return "Balance risks and opportunities."
         else:
-            return "Emphasize potential opportunities and upside. Be willing to tolerate higher risk for potential gains."
+            return "Emphasize potential opportunities. Tolerate higher risk."
 
     def _get_style_instructions(self, level: int) -> str:
-        """Get communication style instructions based on parameter."""
+        """Get communication style."""
         if level < 34:
-            return "Use formal, professional language. Be precise and measured in your statements."
+            return "Use formal, professional language."
         elif level < 67:
-            return "Use clear, accessible language. Be professional but approachable."
+            return "Use clear, accessible language."
         else:
-            return "Use conversational, friendly language. Be direct and engaging."
+            return "Use conversational, friendly language."
 
     def _retrieve_context(self, query: str, k: int = 4) -> str:
         """Retrieve relevant context from the knowledge base."""
         if not self.vectorstore:
             return ""
-
         try:
             docs = self.vectorstore.similarity_search(query, k=k)
             return "\n\n".join([doc.page_content for doc in docs])
@@ -409,70 +160,37 @@ class TradingChatbot:
         visible_params: ParticipantVisibleParams,
         hidden_params: ResearcherControlledParams
     ) -> Optional[ChatResponse]:
-        """
-        Generate proactive advice for a scenario.
-        Returns None if proactive advice should not be shown.
-        """
-        # Check if we should show proactive advice based on proactivity level
-        proactive_threshold = hidden_params.proactivity_level / 100
-        if random.random() > proactive_threshold:
+        """Generate proactive advice for a scenario."""
+        if random.random() > hidden_params.proactivity_level / 100:
             return None
 
-        # Build the prompt
         confidence = self._get_confidence_framing(hidden_params.confidence_framing)
-        depth = self._get_depth_instructions(visible_params.explanation_depth)
-        risk = self._get_risk_framing(hidden_params.risk_bias)
-        style = self._get_style_instructions(visible_params.communication_style)
-
-        # Retrieve relevant context
-        context = self._retrieve_context(
-            f"{scenario.company_name} {scenario.sector} trading analysis"
-        )
+        context = self._retrieve_context(f"{scenario.company_name} {scenario.sector}")
 
-        # Determine what factors to highlight
-        factors_to_mention = []
-        if hidden_params.risk_bias < 50:
-            factors_to_mention = scenario.red_flags[:2] if scenario.red_flags else scenario.key_factors[:2]
-        else:
-            factors_to_mention = scenario.positive_signals[:2] if scenario.positive_signals else scenario.key_factors[:2]
-
-        prompt = f"""
-{style}
-{depth}
-{risk}
+        factors = scenario.red_flags[:2] if hidden_params.risk_bias < 50 else scenario.positive_signals[:2]
+        if not factors:
+            factors = scenario.key_factors[:2]
 
-You are an AI trading advisor. A participant is viewing this trading scenario:
+        prompt = f"""{self._get_style_instructions(visible_params.communication_style)}
+{self._get_depth_instructions(visible_params.explanation_depth)}
 
 Company: {scenario.company_name} ({scenario.company_symbol})
 Sector: {scenario.sector}
-Country: {scenario.country}
-Current Price: {scenario.current_price} credits
-
-Situation:
-{scenario.situation_description}
+Price: {scenario.current_price} credits
 
-Key factors to consider: {', '.join(factors_to_mention)}
-
-Relevant knowledge:
-{context}
-
-You should proactively offer some initial observations about this situation.
-{confidence['prefix']} the situation {confidence['verb']} careful attention {confidence['qualifier']}.
+Situation: {scenario.situation_description}
 
-Your recommendation should lean toward: {scenario.ai_recommendation}
+Key factors: {', '.join(factors)}
 
-Generate a brief proactive message offering your initial take on this situation.
-Do NOT explicitly tell them to BUY, SELL, or HOLD yet - this is an initial observation.
-Keep it natural, as if you're an advisor noticing something they should be aware of.
-"""
+Context: {context}
 
-        response_text = self.llm._call(prompt)
+Generate a brief proactive observation about this situation. Don't say BUY/SELL/HOLD yet - just note what's interesting."""
 
         return ChatResponse(
-            message=response_text,
+            message=self._call_llm(prompt),
             is_proactive=True,
             confidence_level=confidence["level"],
-            sources_used=["market_context", "company_profile"]
+            sources_used=["market_context"]
         )
 
     def generate_ai_recommendation(
@@ -481,55 +199,35 @@ Keep it natural, as if you're an advisor noticing something they should be aware
         visible_params: ParticipantVisibleParams,
         hidden_params: ResearcherControlledParams
     ) -> ChatResponse:
-        """
-        Generate the AI's recommendation for a scenario.
-        This is the main advice given before the participant decides.
-        """
+        """Generate the AI's recommendation for a scenario."""
         confidence = self._get_confidence_framing(hidden_params.confidence_framing)
-        depth = self._get_depth_instructions(visible_params.explanation_depth)
-        risk = self._get_risk_framing(hidden_params.risk_bias)
-        style = self._get_style_instructions(visible_params.communication_style)
-
-        context = self._retrieve_context(
-            f"{scenario.company_name} {scenario.sector} {scenario.ai_recommendation}"
-        )
-
-        prompt = f"""
-{style}
-{depth}
-{risk}
+        context = self._retrieve_context(f"{scenario.company_name} {scenario.sector}")
 
-You are an AI trading advisor. Analyze this situation and provide your recommendation:
+        prompt = f"""{self._get_style_instructions(visible_params.communication_style)}
+{self._get_depth_instructions(visible_params.explanation_depth)}
+{self._get_risk_framing(hidden_params.risk_bias)}
 
 Company: {scenario.company_name} ({scenario.company_symbol})
 Sector: {scenario.sector}
-Country: {scenario.country}
-Current Price: {scenario.current_price} credits
+Price: {scenario.current_price} credits
 
-Situation:
-{scenario.situation_description}
+Situation: {scenario.situation_description}
 
 Key factors: {', '.join(scenario.key_factors)}
-Warning signs: {', '.join(scenario.red_flags) if scenario.red_flags else 'None identified'}
-Positive signals: {', '.join(scenario.positive_signals) if scenario.positive_signals else 'None identified'}
+Warnings: {', '.join(scenario.red_flags) if scenario.red_flags else 'None'}
+Positives: {', '.join(scenario.positive_signals) if scenario.positive_signals else 'None'}
 
-Relevant market knowledge:
-{context}
+Context: {context}
 
-{confidence['prefix']} I {confidence['verb']} the participant to {scenario.ai_recommendation} {confidence['qualifier']}.
+{confidence['prefix']} I {confidence['verb']} to {scenario.ai_recommendation} {confidence['qualifier']}.
 
-Generate your recommendation. Be clear about your suggested action ({scenario.ai_recommendation}).
-Explain your reasoning according to the depth level specified.
-Frame risks according to the risk perspective specified.
-"""
-
-        response_text = self.llm._call(prompt)
+Give your recommendation clearly stating {scenario.ai_recommendation}. Explain your reasoning."""
 
         return ChatResponse(
-            message=response_text,
+            message=self._call_llm(prompt),
             is_proactive=False,
             confidence_level=confidence["level"],
-            sources_used=["market_context", "company_profile", "trading_basics"]
+            sources_used=["market_context", "company_profile"]
         )
 
     def answer_query(
@@ -539,76 +237,38 @@ Frame risks according to the risk perspective specified.
         visible_params: ParticipantVisibleParams,
         hidden_params: ResearcherControlledParams
     ) -> ChatResponse:
-        """
-        Answer a participant's question (reactive query).
-        """
-        depth = self._get_depth_instructions(visible_params.explanation_depth)
-        style = self._get_style_instructions(visible_params.communication_style)
-        risk = self._get_risk_framing(hidden_params.risk_bias)
+        """Answer a participant's question."""
         confidence = self._get_confidence_framing(hidden_params.confidence_framing)
-
-        # Retrieve context based on the query
         context = self._retrieve_context(query)
 
-        # Build scenario context if available
-        scenario_context = ""
+        scenario_info = ""
         if scenario:
-            scenario_context = f"""
-Current scenario:
-Company: {scenario.company_name} ({scenario.company_symbol})
-Sector: {scenario.sector}
-Situation: {scenario.situation_description}
-"""
-
-        # Include chat history for context
-        history_context = ""
-        if self.chat_history:
-            recent_history = self.chat_history[-3:]  # Last 3 exchanges
-            history_context = "Recent conversation:\n" + "\n".join(
-                [f"User: {q}\nAI: {a}" for q, a in recent_history]
-            )
-
-        prompt = f"""
-{style}
-{depth}
-{risk}
-
-You are an AI trading advisor in the TradeVerse. Answer the participant's question.
+            scenario_info = f"Current scenario: {scenario.company_name} ({scenario.company_symbol}) - {scenario.situation_description}"
 
-{scenario_context}
+        prompt = f"""{self._get_style_instructions(visible_params.communication_style)}
+{self._get_depth_instructions(visible_params.explanation_depth)}
 
-{history_context}
+{scenario_info}
 
-Relevant knowledge from your database:
-{context}
+Knowledge: {context}
 
-User question: {query}
-
-Guidelines:
-- Only use information from the TradeVerse (fictional universe)
-- If asked about real-world companies or markets, politely redirect to TradeVerse
-- {confidence['prefix'].lower()} frame your response {confidence['qualifier']}
-- Be helpful but don't make decisions for the participant
-
-Provide your response:
-"""
+Question: {query}
 
-        response_text = self.llm._call(prompt)
+Answer helpfully. Only use TradeVerse information (fictional universe)."""
 
-        # Update chat history
-        self.chat_history.append((query, response_text))
+        response = self._call_llm(prompt)
+        self.chat_history.append((query, response))
 
         return ChatResponse(
-            message=response_text,
+            message=response,
             is_proactive=False,
             confidence_level=confidence["level"],
             sources_used=["knowledge_base"]
         )
 
     def clear_history(self):
-        """Clear the chat history for a new session."""
+        """Clear the chat history."""
         self.chat_history = []
 
 
-# Singleton instance (uses auto-detected provider)
 chatbot = TradingChatbot()