Update app.py

app.py

@@ -1,266 +1,189 @@
 """
-Basic LlamaIndex Agent - Minimal working version
+LlamaIndex Agent with HuggingFace Inference API
 """
 import os
-import sys
 from datetime import datetime
 from dotenv import load_dotenv
 
-# Load environment
+# Load environment variables
 load_dotenv()
 
 print("=" * 60)
-print("🤖 Basic LlamaIndex Agent")
+print("🤖 LlamaIndex Agent - HuggingFace API")
 print("=" * 60)
 
-# Try to import with fallbacks
+# Get token from environment (your secret)
+HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+if not HF_TOKEN:
+    print("❌ HUGGINGFACE_TOKEN not found in environment")
+    print("💡 Make sure your token is set in secrets")
+    exit(1)
+
+print("✅ Found HuggingFace token")
+
+# Import LlamaIndex
 try:
-    # Core imports that always exist
-    from llama_index.core import Settings
+    from llama_index.core import SimpleDirectoryReader, VectorStoreIndex, Settings
     from llama_index.core.tools import FunctionTool
+    from llama_index.core.agent import ReActAgent
+    from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
     
-    # Try to import LLM
-    try:
-        from llama_index.llms.huggingface import HuggingFaceLLM
-        HAS_HF_LLM = True
-    except ImportError:
-        print("⚠️ llama-index-llms-huggingface not installed")
-        print("💡 Using dummy LLM for testing")
-        HAS_HF_LLM = False
-    
-    # Try to import embeddings
-    try:
-        from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-        HAS_EMBEDDINGS = True
-    except ImportError:
-        print("⚠️ llama-index-embeddings-huggingface not installed")
-        HAS_EMBEDDINGS = False
-        
     print("✅ LlamaIndex imports successful")
     
 except ImportError as e:
-    print(f"❌ Critical import error: {e}")
-    print("\n💡 Install with: pip install llama-index-core transformers torch")
-    sys.exit(1)
+    print(f"❌ Import error: {e}")
+    exit(1)
+
+# Initialize HuggingFace API LLM
+print("\n📡 Connecting to HuggingFace API...")
 
-# Setup LLM (with fallback)
-if HAS_HF_LLM:
+try:
+    # Initialize the LLM with HuggingFace API
+    llm = HuggingFaceInferenceAPI(
+        model_name="Qwen/Qwen2.5-Coder-32B-Instruct",  # Use your preferred model
+        token=HF_TOKEN,
+        context_window=8192,
+        max_new_tokens=512,
+        generate_kwargs={"temperature": 0.1}
+    )
+    
+    Settings.llm = llm
+    print(f"✅ Connected to: Qwen/Qwen2.5-Coder-32B-Instruct")
+    
+except Exception as e:
+    print(f"❌ API connection failed: {e}")
+    print("🔄 Trying alternative model...")
+    
+    # Fallback to Mistral if Qwen fails
     try:
-        print("📦 Loading Hugging Face model...")
-        Settings.llm = HuggingFaceLLM(
-            model_name="distilbert/distilgpt2",  # Smallest model
-            tokenizer_name="distilbert/distilgpt2",
-            max_new_tokens=50,
-            generate_kwargs={"temperature": 0.1, "do_sample": True},
-            device_map="cpu"
+        llm = HuggingFaceInferenceAPI(
+            model_name="mistralai/Mistral-7B-Instruct-v0.2",
+            token=HF_TOKEN,
+            context_window=4096,
+            max_new_tokens=256
         )
-        print("✅ LLM loaded successfully")
+        Settings.llm = llm
+        print(f"✅ Connected to: Mistral-7B-Instruct")
+    except Exception as e2:
+        print(f"❌ All connections failed: {e2}")
+        exit(1)
+
+# ====== DOCUMENT SETUP ======
+def setup_documents():
+    """Setup document index"""
+    data_dir = "./data"
+    os.makedirs(data_dir, exist_ok=True)
+    
+    # Create sample file if empty
+    sample_file = f"{data_dir}/sample.txt"
+    if not os.path.exists(sample_file):
+        with open(sample_file, "w") as f:
+            f.write("LlamaIndex is a framework for building LLM applications.\n")
+            f.write("It helps you connect your data to large language models.\n")
+            f.write("HuggingFace provides access to thousands of models.\n")
+            f.write("The answer to life, the universe, and everything is 42.\n")
+        print(f"📄 Created {sample_file}")
+    
+    # Load documents
+    try:
+        documents = SimpleDirectoryReader(data_dir).load_data()
+        index = VectorStoreIndex.from_documents(documents)
+        print(f"✅ Loaded {len(documents)} documents")
+        return index
     except Exception as e:
-        print(f"⚠️ Could not load HF model: {e}")
-        HAS_HF_LLM = False
+        print(f"⚠️ Document error: {e}")
+        return VectorStoreIndex([])
 
-if not HAS_HF_LLM:
-    # Fallback to a mock LLM
-    print("🔄 Using simple mock LLM")
-    from llama_index.core.llms.mock import MockLLM
-    Settings.llm = MockLLM()
+# Create document index
+index = setup_documents()
 
-# Setup embeddings (optional)
-if HAS_EMBEDDINGS:
+# ====== TOOLS ======
+def calculate(expr: str) -> str:
+    """Calculate math expressions"""
     try:
-        Settings.embed_model = HuggingFaceEmbedding(
-            model_name="sentence-transformers/all-MiniLM-L6-v2",
-            device="cpu"
-        )
+        allowed = set("0123456789+-*/(). ")
+        if all(c in allowed for c in expr):
+            return f"Result: {eval(expr)}"
+        return "Invalid characters"
     except:
-        pass
+        return "Math error"
 
-# ====== TOOLS DEFINITION ======
-# Define tools directly in app.py (no separate file needed)
+def get_time() -> str:
+    """Get current time"""
+    return f"Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
 
-def calculate(expression: str) -> str:
-    """Calculate mathematical expressions"""
+def search_docs(query: str) -> str:
+    """Search documents using direct query engine"""
     try:
-        # Safe evaluation with only basic math
-        allowed = set("0123456789+-*/(). ")
-        if all(c in allowed for c in expression):
-            result = eval(expression)
-            return f"The answer is: {result}"
-        return "Please use only numbers and + - * / ( )"
+        query_engine = index.as_query_engine(
+            llm=Settings.llm,
+            response_mode="tree_summarize"
+        )
+        response = query_engine.query(query)
+        return str(response)
     except Exception as e:
-        return f"Calculation error: {str(e)}"
+        return f"Search error: {e}"
 
-def get_time(query: str = "") -> str:
-    """Get current date and time"""
-    now = datetime.now()
-    return f"Current date and time: {now.strftime('%A, %B %d, %Y at %I:%M:%S %p')}"
-
-def list_files(query: str = "") -> str:
-    """List files in the data directory"""
-    data_dir = "data"
-    if not os.path.exists(data_dir):
-        return "No 'data' directory found. Create one to add documents."
-    
-    files = os.listdir(data_dir)
-    if not files:
-        return "No files in data directory."
-    
-    return f"Files in data directory:\n" + "\n".join([f"• {f}" for f in files])
-
-def simple_search(query: str) -> str:
-    """Search for text in files"""
-    if not query:
-        return "Please provide a search query."
-    
-    data_dir = "data"
-    if not os.path.exists(data_dir):
-        return "No data directory found."
-    
-    results = []
-    for filename in os.listdir(data_dir):
-        filepath = os.path.join(data_dir, filename)
-        if os.path.isfile(filepath) and filename.endswith(('.txt', '.md', '.py')):
-            try:
-                with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
-                    content = f.read()
-                    if query.lower() in content.lower():
-                        results.append(filename)
-            except:
-                continue
-    
-    if results:
-        return f"Found '{query}' in: {', '.join(results)}"
-    else:
-        return f"No results found for '{query}'"
-
-# Create tool objects
+# Create tools
 tools = [
+    FunctionTool.from_defaults(
+        search_docs,
+        name="search_documents",
+        description="Search through your indexed documents for information"
+    ),
     FunctionTool.from_defaults(
         calculate,
         name="calculator",
-        description="Useful for mathematical calculations. Input should be a valid math expression like '2 + 2' or '5 * (3 + 4)'"
+        description="Calculate mathematical expressions"
     ),
     FunctionTool.from_defaults(
         get_time,
-        name="time",
-        description="Get the current date and time. No input needed."
-    ),
-    FunctionTool.from_defaults(
-        list_files,
-        name="list_files",
-        description="List all files available in the data directory."
-    ),
-    FunctionTool.from_defaults(
-        simple_search,
-        name="search",
-        description="Search for text in files within the data directory."
+        name="get_time",
+        description="Get current date and time"
     )
 ]
 
 print(f"🛠️  Created {len(tools)} tools")
 
-# ====== AGENT CREATION ======
-# Try different ways to create an agent based on version
-
-agent = None
-agent_type = "Unknown"
-
+# ====== AGENT ======
 try:
-    # Try v0.10+ method
-    from llama_index.core.agent import AgentRunner, ReActAgentWorker
-    agent_worker = ReActAgentWorker.from_tools(
+    agent = ReActAgent.from_tools(
         tools=tools,
         llm=Settings.llm,
         verbose=True,
-        max_iterations=3
+        max_iterations=5
     )
-    agent = AgentRunner(agent_worker)
-    agent_type = "ReActAgent (v0.10+)"
-    print(f"✅ Created {agent_type}")
-except:
-    try:
-        # Try v0.9 method
-        from llama_index.core.agent import ReActAgent
-        agent = ReActAgent.from_tools(
-            tools=tools,
-            llm=Settings.llm,
-            verbose=True,
-            max_iterations=3
-        )
-        agent_type = "ReActAgent (v0.9)"
-        print(f"✅ Created {agent_type}")
-    except:
-        try:
-            # Try simple agent
-            from llama_index.core.agent import AgentRunner, FunctionCallingAgentWorker
-            agent_worker = FunctionCallingAgentWorker.from_tools(
-                tools=tools,
-                llm=Settings.llm
-            )
-            agent = AgentRunner(agent_worker)
-            agent_type = "FunctionCallingAgent"
-            print(f"✅ Created {agent_type}")
-        except:
-            # Last resort: Use QueryEngine with tools
-            from llama_index.core.query_engine import ToolRetrieverRouterQueryEngine
-            from llama_index.core.objects import ObjectIndex
-            from llama_index.core import VectorStoreIndex
-            from llama_index.core.schema import TextNode
-            
-            # Create a simple router
-            nodes = [TextNode(text=f"Tool: {tool.metadata.name} - {tool.metadata.description}") 
-                    for tool in tools]
-            index = VectorStoreIndex(nodes)
-            
-            class SimpleAgent:
-                def __init__(self, tools, llm):
-                    self.tools = {tool.metadata.name: tool for tool in tools}
-                    self.llm = llm
-                    
-                def chat(self, query):
-                    # Simple routing logic
-                    if "time" in query.lower():
-                        return get_time()
-                    elif any(op in query for op in ['+', '-', '*', '/', 'calc']):
-                        # Extract numbers for calculation
-                        import re
-                        nums = re.findall(r'\d+', query)
-                        if nums:
-                            return calculate("+".join(nums))
-                    elif "search" in query.lower():
-                        return simple_search(query.replace("search", "").strip())
-                    elif "file" in query.lower():
-                        return list_files()
-                    
-                    # Default response
-                    return f"I received: '{query}'. I can help with calculations, time, files, and search."
-            
-            agent = SimpleAgent(tools, Settings.llm)
-            agent_type = "SimpleRouter"
-            print(f"✅ Created {agent_type}")
-
-# ====== MAIN CHAT LOOP ======
-def main():
-    # Create data directory if it doesn't exist
-    os.makedirs("data", exist_ok=True)
+    print("✅ Agent created successfully")
+except Exception as e:
+    print(f"⚠️ Agent creation error: {e}")
     
-    # Create a sample file
-    sample_file = os.path.join("data", "sample.txt")
-    if not os.path.exists(sample_file):
-        with open(sample_file, "w") as f:
-            f.write("Welcome to the LlamaIndex agent.\n")
-            f.write("This is a sample document for testing.\n")
-            f.write("You can search for words like 'LlamaIndex', 'agent', or 'sample'.\n")
-        print(f"📄 Created sample file: {sample_file}")
+    # Create simple fallback
+    class SimpleAgent:
+        def chat(self, query):
+            if any(op in query for op in ['+', '-', '*', '/']):
+                return calculate(query)
+            elif "time" in query.lower():
+                return get_time()
+            else:
+                return search_docs(query)
     
+    agent = SimpleAgent()
+    print("✅ Created simple agent")
+
+# ====== DIRECT QUERY ENGINE (like your example) ======
+direct_engine = index.as_query_engine(
+    llm=Settings.llm,
+    response_mode="tree_summarize"
+)
+
+# ====== MAIN ======
+def main():
     print("\n" + "=" * 60)
-    print(f"Agent Type: {agent_type}")
-    print("Available tools: calculator, time, list_files, search")
-    print("\n💡 Examples:")
+    print("🎯 Ready! Try these commands:")
+    print("• 'search What is LlamaIndex?'")
     print("• 'What is 15 * 3?'")
     print("• 'What time is it?'")
-    print("• 'List my files'")
-    print("• 'Search for LlamaIndex'")
+    print("• 'direct What is the meaning of life?'")
     print("• 'exit' to quit")
     print("=" * 60)
     
@@ -268,31 +191,35 @@ def main():
         try:
             user_input = input("\nYou: ").strip()
             
-            if user_input.lower() in ['exit', 'quit', 'bye']:
+            if user_input.lower() == 'exit':
                 print("\n👋 Goodbye!")
                 break
-            elif user_input.lower() in ['help', '?']:
+            elif user_input.lower() == 'help':
                 print("\n📋 Help:")
-                print("• I can do calculations: '2 + 2', '5 * 10'")
-                print("• I can tell time: 'what time is it?'")
-                print("• I can list files: 'list files'")
-                print("• I can search: 'search for sample'")
-                print("• Type 'exit' to quit")
+                print("• Ask questions - I'll search your documents")
+                print("• Do math: '2 + 2', '5 * 10'")
+                print("• Ask for time")
+                print("• Start with 'direct ' for direct query")
+                print("• 'exit' to quit")
                 continue
-            elif not user_input:
+            elif user_input.lower().startswith('direct '):
+                # Direct query like your example
+                question = user_input[7:].strip()
+                print(f"�� Direct query: {question}")
+                response = direct_engine.query(question)
+                print(f"\n🤖 Answer: {response}")
                 continue
             
-            # Get response
-            print("🤔 Thinking...", end="", flush=True)
+            # Use agent
+            print("🤔 Thinking...")
             response = agent.chat(user_input)
-            print(f"\r🤖 Agent: {response}\n")
+            print(f"\n🤖 Agent: {response}")
             
         except KeyboardInterrupt:
             print("\n\n👋 Goodbye!")
             break
         except Exception as e:
-            print(f"\r❌ Error: {str(e)}")
-            print("💡 Try a simpler query or type 'help'")
+            print(f"\n❌ Error: {str(e)}")
 
 if __name__ == "__main__":
     main()