Update veryfinal.py

veryfinal.py

@@ -1,6 +1,6 @@
 """
-Enhanced Multi-LLM Agent System with Supabase FAISS Integration
-Complete system for document insertion, retrieval, and question answering
+Open-Source Multi-LLM Agent System
+Uses only free and open-source models - no paid APIs required
 """
 
 import os
@@ -10,28 +10,38 @@ import operator
 from typing import List, Dict, Any, TypedDict, Annotated, Optional
 from dotenv import load_dotenv
 
+# Core LangChain imports
 from langchain_core.tools import tool
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader
 from langgraph.graph import StateGraph, END
 from langgraph.checkpoint.memory import MemorySaver
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-from langchain_groq import ChatGroq
 
-# Supabase and FAISS imports
+# Open-source model integrations
+from langchain_groq import ChatGroq  # Free tier available
+from langchain_community.llms import Ollama
+from langchain_community.chat_models import ChatOllama
+
+# Hugging Face integration for open-source models
+try:
+    from langchain_huggingface import HuggingFacePipeline
+    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+    HF_AVAILABLE = True
+except ImportError:
+    HF_AVAILABLE = False
+
+# Vector database imports
 import faiss
 import numpy as np
 from sentence_transformers import SentenceTransformer
-from supabase import create_client, Client
-import pandas as pd
 import json
-import pickle
 
 load_dotenv()
 
-# Enhanced system prompt for question-answering
+# Enhanced system prompt
 ENHANCED_SYSTEM_PROMPT = (
-    "You are a helpful assistant tasked with answering questions using a set of tools. "
+    "You are a helpful assistant tasked with answering questions using available tools. "
     "You must provide accurate, comprehensive answers based on available information. "
     "When answering questions, follow these guidelines:\n"
     "1. Use available tools to gather information when needed\n"
@@ -74,21 +84,35 @@ def modulus(a: int, b: int) -> int:
 
 @tool
 def optimized_web_search(query: str) -> str:
-    """Perform an optimized web search using TavilySearchResults."""
+    """Perform web search using free DuckDuckGo (fallback if Tavily not available)."""
     try:
-        time.sleep(random.uniform(0.7, 1.5))
-        search_tool = TavilySearchResults(max_results=3)
-        docs = search_tool.invoke({"query": query})
-        return "\n\n---\n\n".join(
-            f"<Doc url='{d.get('url','')}'>{d.get('content','')[:800]}</Doc>"
-            for d in docs
-        )
+        # Try Tavily first (free tier)
+        if os.getenv("TAVILY_API_KEY"):
+            time.sleep(random.uniform(0.7, 1.5))
+            search_tool = TavilySearchResults(max_results=3)
+            docs = search_tool.invoke({"query": query})
+            return "\n\n---\n\n".join(
+                f"<Doc url='{d.get('url','')}'>{d.get('content','')[:800]}</Doc>"
+                for d in docs
+            )
+        else:
+            # Fallback to DuckDuckGo (completely free)
+            try:
+                from duckduckgo_search import DDGS
+                with DDGS() as ddgs:
+                    results = list(ddgs.text(query, max_results=3))
+                    return "\n\n---\n\n".join(
+                        f"<Doc url='{r.get('href','')}'>{r.get('body','')[:800]}</Doc>"
+                        for r in results
+                    )
+            except ImportError:
+                return "Web search not available - install duckduckgo-search for free web search"
     except Exception as e:
         return f"Web search failed: {e}"
 
 @tool
 def optimized_wiki_search(query: str) -> str:
-    """Perform an optimized Wikipedia search and return content snippets."""
+    """Perform Wikipedia search - completely free."""
     try:
         time.sleep(random.uniform(0.3, 1))
         docs = WikipediaLoader(query=query, load_max_docs=2).load()
@@ -99,88 +123,120 @@ def optimized_wiki_search(query: str) -> str:
     except Exception as e:
         return f"Wikipedia search failed: {e}"
 
-# ---- Supabase FAISS Vector Database Integration ----
-class SupabaseFAISSVectorDB:
-    """Enhanced vector database combining FAISS with Supabase for persistent storage"""
+# ---- Open-Source Model Manager ----
+class OpenSourceModelManager:
+    """Manages only open-source and free models"""
     
     def __init__(self):
-        # Initialize Supabase client
-        self.supabase_url = os.getenv("SUPABASE_URL")
-        self.supabase_key = os.getenv("SUPABASE_SERVICE_KEY")
-        if self.supabase_url and self.supabase_key:
-            self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
-        else:
-            self.supabase = None
-            print("Supabase credentials not found, running without vector database")
+        self.available_models = {}
+        self._initialize_models()
+    
+    def _initialize_models(self):
+        """Initialize only open-source models"""
         
-        # Initialize embedding model
-        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-        self.embedding_dim = self.embedding_model.get_sentence_embedding_dimension()
+        # 1. Groq (Free tier with open-source models)
+        if os.getenv("GROQ_API_KEY"):
+            try:
+                self.available_models['groq_llama3_70b'] = ChatGroq(
+                    model="llama3-70b-8192", 
+                    temperature=0, 
+                    api_key=os.getenv("GROQ_API_KEY")
+                )
+                self.available_models['groq_llama3_8b'] = ChatGroq(
+                    model="llama3-8b-8192", 
+                    temperature=0, 
+                    api_key=os.getenv("GROQ_API_KEY")
+                )
+                self.available_models['groq_mixtral'] = ChatGroq(
+                    model="mixtral-8x7b-32768", 
+                    temperature=0, 
+                    api_key=os.getenv("GROQ_API_KEY")
+                )
+                self.available_models['groq_gemma'] = ChatGroq(
+                    model="gemma-7b-it", 
+                    temperature=0, 
+                    api_key=os.getenv("GROQ_API_KEY")
+                )
+                print("Groq models initialized (free tier)")
+            except Exception as e:
+                print(f"Groq models not available: {e}")
         
-        # Initialize FAISS index
-        self.index = faiss.IndexFlatL2(self.embedding_dim)
-        self.document_store = []  # Local cache for documents
-    
-    def insert_question_data(self, data: Dict[str, Any]) -> bool:
-        """Insert question data into both Supabase and FAISS"""
+        # 2. Ollama (Completely free local models)
         try:
-            question_text = data.get("Question", "")
-            embedding = self.embedding_model.encode([question_text])[0]
-            
-            # Insert into Supabase if available
-            if self.supabase:
-                question_data = {
-                    "task_id": data.get("task_id"),
-                    "question": question_text,
-                    "final_answer": data.get("Final answer"),
-                    "level": data.get("Level"),
-                    "file_name": data.get("file_name", ""),
-                    "embedding": embedding.tolist()
-                }
-                self.supabase.table("questions").insert(question_data).execute()
-            
-            # Add to local FAISS index
-            self.index.add(embedding.reshape(1, -1).astype('float32'))
-            self.document_store.append({
-                "task_id": data.get("task_id"),
-                "question": question_text,
-                "answer": data.get("Final answer"),
-                "level": data.get("Level")
-            })
-            
-            return True
+            # Test if Ollama is running
+            test_model = ChatOllama(model="llama3", base_url="http://localhost:11434")
+            # If no error, add Ollama models
+            self.available_models['ollama_llama3'] = ChatOllama(model="llama3")
+            self.available_models['ollama_llama3_70b'] = ChatOllama(model="llama3:70b")
+            self.available_models['ollama_mistral'] = ChatOllama(model="mistral")
+            self.available_models['ollama_phi3'] = ChatOllama(model="phi3")
+            self.available_models['ollama_codellama'] = ChatOllama(model="codellama")
+            self.available_models['ollama_gemma'] = ChatOllama(model="gemma")
+            self.available_models['ollama_qwen'] = ChatOllama(model="qwen")
+            print("Ollama models initialized (local)")
         except Exception as e:
-            print(f"Error inserting data: {e}")
-            return False
+            print(f"Ollama not available: {e}")
+        
+        # 3. Hugging Face Transformers (Completely free)
+        if HF_AVAILABLE:
+            try:
+                # Small models that can run on CPU
+                self.available_models['hf_gpt2'] = self._create_hf_model("gpt2")
+                self.available_models['hf_distilgpt2'] = self._create_hf_model("distilgpt2")
+                print("Hugging Face models initialized (local)")
+            except Exception as e:
+                print(f"Hugging Face models not available: {e}")
+        
+        print(f"Total available open-source models: {len(self.available_models)}")
     
-    def search_similar_questions(self, query: str, k: int = 3) -> List[Dict[str, Any]]:
-        """Search for similar questions using vector similarity"""
+    def _create_hf_model(self, model_name: str):
+        """Create Hugging Face pipeline model"""
         try:
-            if self.index.ntotal == 0:
-                return []
-            
-            query_embedding = self.embedding_model.encode([query])[0]
-            k = min(k, self.index.ntotal)
-            distances, indices = self.index.search(
-                query_embedding.reshape(1, -1).astype('float32'), k
+            pipe = pipeline(
+                "text-generation",
+                model=model_name,
+                max_length=512,
+                do_sample=True,
+                temperature=0.7,
+                pad_token_id=50256
             )
-            
-            results = []
-            for i, idx in enumerate(indices[0]):
-                if 0 <= idx < len(self.document_store):
-                    doc = self.document_store[idx]
-                    results.append({
-                        "task_id": doc["task_id"],
-                        "question": doc["question"],
-                        "answer": doc["answer"],
-                        "similarity_score": 1 / (1 + distances[0][i]),
-                        "distance": float(distances[0][i])
-                    })
-            
-            return results
+            return HuggingFacePipeline(pipeline=pipe)
         except Exception as e:
-            print(f"Error searching similar questions: {e}")
-            return []
+            print(f"Failed to create HF model {model_name}: {e}")
+            return None
+    
+    def get_model(self, model_name: str):
+        """Get a specific model by name"""
+        return self.available_models.get(model_name)
+    
+    def list_available_models(self) -> List[str]:
+        """List all available model names"""
+        return list(self.available_models.keys())
+    
+    def get_best_model_for_task(self, task_type: str):
+        """Get the best available model for a specific task type"""
+        if task_type == "reasoning":
+            # Prefer larger models for reasoning
+            for model_name in ['groq_llama3_70b', 'ollama_llama3_70b', 'groq_mixtral', 'ollama_llama3']:
+                if model_name in self.available_models:
+                    return self.available_models[model_name]
+        
+        elif task_type == "coding":
+            # Prefer code-specialized models
+            for model_name in ['ollama_codellama', 'groq_llama3_70b', 'ollama_llama3']:
+                if model_name in self.available_models:
+                    return self.available_models[model_name]
+        
+        elif task_type == "fast":
+            # Prefer fast, smaller models
+            for model_name in ['groq_llama3_8b', 'groq_gemma', 'ollama_phi3', 'hf_distilgpt2']:
+                if model_name in self.available_models:
+                    return self.available_models[model_name]
+        
+        # Default fallback to first available
+        if self.available_models:
+            return list(self.available_models.values())[0]
+        return None
 
 # ---- Enhanced Agent State ----
 class EnhancedAgentState(TypedDict):
@@ -190,159 +246,61 @@ class EnhancedAgentState(TypedDict):
     agent_type: str
     final_answer: str
     perf: Dict[str, Any]
-    agno_resp: str
     tools_used: List[str]
     reasoning: str
-    similar_questions: List[Dict[str, Any]]
+    model_used: str
 
-# ---- Enhanced Multi-LLM System ----
-class HybridLangGraphMultiLLMSystem:
+# ---- Open-Source Multi-LLM System ----
+class OpenSourceMultiLLMSystem:
     """
-    Advanced question-answering system with multi-LLM support and vector database integration
+    Multi-LLM system using only open-source and free models
     """
     
-    def __init__(self, provider="groq"):
-        self.provider = provider
+    def __init__(self):
+        self.model_manager = OpenSourceModelManager()
         self.tools = [
             multiply, add, subtract, divide, modulus,
             optimized_web_search, optimized_wiki_search
         ]
-        
-        # Initialize vector database
-        self.vector_db = SupabaseFAISSVectorDB()
-        
         self.graph = self._build_graph()
-
-    def _llm(self, model_name: str) -> ChatGroq:
-        """Create a Groq LLM instance."""
-        return ChatGroq(
-            model=model_name,
-            temperature=0,
-            api_key=os.getenv("GROQ_API_KEY")
-        )
-
+    
     def _build_graph(self) -> StateGraph:
-        """Build the LangGraph state machine with enhanced capabilities."""
-        # Initialize LLMs
-        llama8_llm = self._llm("llama3-8b-8192")
-        llama70_llm = self._llm("llama3-70b-8192")
-        deepseek_llm = self._llm("deepseek-chat")
-
+        """Build the LangGraph state machine with open-source models."""
+        
         def router(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Route queries to appropriate LLM based on complexity and content analysis."""
+            """Route queries to appropriate model based on complexity and content analysis."""
             q = st["query"].lower()
             
             # Enhanced routing logic
             if any(keyword in q for keyword in ["calculate", "compute", "math", "multiply", "add", "subtract", "divide"]):
-                t = "llama70"  # Use more powerful model for calculations
+                model_type = "reasoning"
+                agent_type = "math"
             elif any(keyword in q for keyword in ["search", "find", "lookup", "wikipedia", "information about"]):
-                t = "search_enhanced"  # Use search-enhanced processing
-            elif "deepseek" in q or any(keyword in q for keyword in ["analyze", "reasoning", "complex"]):
-                t = "deepseek"
-            elif "llama-8" in q:
-                t = "llama8"
+                model_type = "fast"
+                agent_type = "search_enhanced"
+            elif any(keyword in q for keyword in ["code", "programming", "function", "algorithm"]):
+                model_type = "coding"
+                agent_type = "coding"
             elif len(q.split()) > 20:  # Complex queries
-                t = "llama70"
+                model_type = "reasoning"
+                agent_type = "complex"
             else:
-                t = "llama8"  # Default for simple queries
-                
-            # Search for similar questions
-            similar_questions = self.vector_db.search_similar_questions(st["query"], k=3)
+                model_type = "fast"
+                agent_type = "simple"
             
-            return {**st, "agent_type": t, "tools_used": [], "reasoning": "", "similar_questions": similar_questions}
-
-        def llama8_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process query with Llama-3 8B model."""
-            t0 = time.time()
-            try:
-                # Add similar questions context if available
-                context = ""
-                if st.get("similar_questions"):
-                    context = "\n\nSimilar questions for reference:\n"
-                    for sq in st["similar_questions"][:2]:
-                        context += f"Q: {sq['question']}\nA: {sq['answer']}\n"
-                
-                enhanced_query = f"""
-                Question: {st["query"]}
-                {context}
-                Please provide a direct, accurate answer to this question.
-                """
-                
-                sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = llama8_llm.invoke([sys, HumanMessage(content=enhanced_query)])
-                
-                answer = res.content.strip()
-                if "FINAL ANSWER:" in answer:
-                    answer = answer.split("FINAL ANSWER:")[-1].strip()
-                
-                return {**st,
-                        "final_answer": answer,
-                        "reasoning": "Used Llama-3 8B with similar questions context",
-                        "perf": {"time": time.time() - t0, "prov": "Groq-Llama3-8B"}}
-            except Exception as e:
-                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
-
-        def llama70_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process query with Llama-3 70B model."""
-            t0 = time.time()
-            try:
-                # Add similar questions context if available
-                context = ""
-                if st.get("similar_questions"):
-                    context = "\n\nSimilar questions for reference:\n"
-                    for sq in st["similar_questions"][:2]:
-                        context += f"Q: {sq['question']}\nA: {sq['answer']}\n"
-                
-                enhanced_query = f"""
-                Question: {st["query"]}
-                {context}
-                Please provide a direct, accurate answer to this question.
-                """
-                
-                sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = llama70_llm.invoke([sys, HumanMessage(content=enhanced_query)])
-                
-                answer = res.content.strip()
-                if "FINAL ANSWER:" in answer:
-                    answer = answer.split("FINAL ANSWER:")[-1].strip()
-                
-                return {**st,
-                        "final_answer": answer,
-                        "reasoning": "Used Llama-3 70B for complex reasoning with context",
-                        "perf": {"time": time.time() - t0, "prov": "Groq-Llama3-70B"}}
-            except Exception as e:
-                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
+            # Get the best model for this task
+            selected_model = self.model_manager.get_best_model_for_task(model_type)
+            model_name = "unknown"
+            for name, model in self.model_manager.available_models.items():
+                if model == selected_model:
+                    model_name = name
+                    break
+            
+            return {**st, "agent_type": agent_type, "tools_used": [], "reasoning": "", "model_used": model_name}
 
-        def deepseek_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process query with DeepSeek model."""
-            t0 = time.time()
-            try:
-                # Add similar questions context if available
-                context = ""
-                if st.get("similar_questions"):
-                    context = "\n\nSimilar questions for reference:\n"
-                    for sq in st["similar_questions"][:2]:
-                        context += f"Q: {sq['question']}\nA: {sq['answer']}\n"
-                
-                enhanced_query = f"""
-                Question: {st["query"]}
-                {context}
-                Please provide a direct, accurate answer to this question.
-                """
-                
-                sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = deepseek_llm.invoke([sys, HumanMessage(content=enhanced_query)])
-                
-                answer = res.content.strip()
-                if "FINAL ANSWER:" in answer:
-                    answer = answer.split("FINAL ANSWER:")[-1].strip()
-                
-                return {**st,
-                        "final_answer": answer,
-                        "reasoning": "Used DeepSeek for advanced reasoning and analysis",
-                        "perf": {"time": time.time() - t0, "prov": "Groq-DeepSeek"}}
-            except Exception as e:
-                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
+        def math_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Process mathematical queries."""
+            return self._process_with_model(st, "reasoning", "Mathematical calculation using open-source model")
 
         def search_enhanced_node(st: EnhancedAgentState) -> EnhancedAgentState:
             """Process query with search enhancement."""
@@ -361,73 +319,111 @@ class HybridLangGraphMultiLLMSystem:
                     search_results = optimized_web_search.invoke({"query": query})
                     tools_used.append("web_search")
                 
-                # Add similar questions context
-                context = ""
-                if st.get("similar_questions"):
-                    context = "\n\nSimilar questions for reference:\n"
-                    for sq in st["similar_questions"][:2]:
-                        context += f"Q: {sq['question']}\nA: {sq['answer']}\n"
-                
                 enhanced_query = f"""
                 Original Question: {query}
                 
                 Search Results:
                 {search_results}
-                {context}
                 
-                Based on the search results and similar questions above, provide a direct answer to the original question.
+                Based on the search results above, provide a direct answer to the original question.
                 """
                 
-                sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                res = llama70_llm.invoke([sys, HumanMessage(content=enhanced_query)])
-                
-                answer = res.content.strip()
-                if "FINAL ANSWER:" in answer:
-                    answer = answer.split("FINAL ANSWER:")[-1].strip()
-                
-                return {**st,
-                        "final_answer": answer,
-                        "tools_used": tools_used,
-                        "reasoning": "Used search enhancement with similar questions context",
-                        "perf": {"time": time.time() - t0, "prov": "Search-Enhanced-Llama70"}}
+                # Use fast model for search-enhanced queries
+                model = self.model_manager.get_best_model_for_task("fast")
+                if model:
+                    sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
+                    res = model.invoke([sys, HumanMessage(content=enhanced_query)])
+                    
+                    answer = res.content.strip() if hasattr(res, 'content') else str(res).strip()
+                    if "FINAL ANSWER:" in answer:
+                        answer = answer.split("FINAL ANSWER:")[-1].strip()
+                    
+                    return {**st,
+                            "final_answer": answer,
+                            "tools_used": tools_used,
+                            "reasoning": "Used search enhancement with open-source model",
+                            "perf": {"time": time.time() - t0, "prov": "Search-Enhanced"}}
+                else:
+                    return {**st, "final_answer": "No models available", "perf": {"error": "No models"}}
             except Exception as e:
                 return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
 
+        def coding_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Process coding-related queries."""
+            return self._process_with_model(st, "coding", "Code generation using open-source model")
+
+        def complex_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Process complex queries."""
+            return self._process_with_model(st, "reasoning", "Complex reasoning using open-source model")
+
+        def simple_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Process simple queries."""
+            return self._process_with_model(st, "fast", "Simple query using fast open-source model")
+
         # Build graph
         g = StateGraph(EnhancedAgentState)
         g.add_node("router", router)
-        g.add_node("llama8", llama8_node)
-        g.add_node("llama70", llama70_node)
-        g.add_node("deepseek", deepseek_node)
+        g.add_node("math", math_node)
         g.add_node("search_enhanced", search_enhanced_node)
+        g.add_node("coding", coding_node)
+        g.add_node("complex", complex_node)
+        g.add_node("simple", simple_node)
         
         g.set_entry_point("router")
         g.add_conditional_edges("router", lambda s: s["agent_type"], {
-            "llama8": "llama8",
-            "llama70": "llama70",
-            "deepseek": "deepseek",
-            "search_enhanced": "search_enhanced"
+            "math": "math",
+            "search_enhanced": "search_enhanced",
+            "coding": "coding",
+            "complex": "complex",
+            "simple": "simple"
         })
         
-        for node in ["llama8", "llama70", "deepseek", "search_enhanced"]:
+        for node in ["math", "search_enhanced", "coding", "complex", "simple"]:
             g.add_edge(node, END)
             
         return g.compile(checkpointer=MemorySaver())
+    
+    def _process_with_model(self, st: EnhancedAgentState, model_type: str, reasoning: str) -> EnhancedAgentState:
+        """Process query with specified model type"""
+        t0 = time.time()
+        try:
+            model = self.model_manager.get_best_model_for_task(model_type)
+            if not model:
+                return {**st, "final_answer": "No suitable model available", "perf": {"error": "No model"}}
+            
+            enhanced_query = f"""
+            Question: {st["query"]}
+            
+            Please provide a direct, accurate answer to this question.
+            """
+            
+            sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
+            res = model.invoke([sys, HumanMessage(content=enhanced_query)])
+            
+            answer = res.content.strip() if hasattr(res, 'content') else str(res).strip()
+            if "FINAL ANSWER:" in answer:
+                answer = answer.split("FINAL ANSWER:")[-1].strip()
+            
+            return {**st,
+                    "final_answer": answer,
+                    "reasoning": reasoning,
+                    "perf": {"time": time.time() - t0, "prov": f"OpenSource-{model_type}"}}
+        except Exception as e:
+            return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
 
     def process_query(self, q: str) -> str:
-        """Process a query through the enhanced multi-LLM system."""
+        """Process a query through the open-source multi-LLM system."""
         state = {
             "messages": [HumanMessage(content=q)],
             "query": q,
             "agent_type": "",
             "final_answer": "",
             "perf": {},
-            "agno_resp": "",
             "tools_used": [],
             "reasoning": "",
-            "similar_questions": []
+            "model_used": ""
         }
-        cfg = {"configurable": {"thread_id": f"enhanced_qa_{hash(q)}"}}
+        cfg = {"configurable": {"thread_id": f"opensource_qa_{hash(q)}"}}
         
         try:
             out = self.graph.invoke(state, cfg)
@@ -441,53 +437,51 @@ class HybridLangGraphMultiLLMSystem:
         except Exception as e:
             return f"Error processing query: {e}"
     
-    def load_metadata_from_jsonl(self, jsonl_file_path: str) -> int:
-        """Load question metadata from JSONL file into vector database"""
-        success_count = 0
-        
-        try:
-            with open(jsonl_file_path, 'r', encoding='utf-8') as file:
-                for line_num, line in enumerate(file, 1):
-                    try:
-                        data = json.loads(line.strip())
-                        if self.vector_db.insert_question_data(data):
-                            success_count += 1
-                        
-                        if line_num % 10 == 0:
-                            print(f"Processed {line_num} records, {success_count} successful")
-                            
-                    except json.JSONDecodeError as e:
-                        print(f"JSON decode error on line {line_num}: {e}")
-                    except Exception as e:
-                        print(f"Error processing line {line_num}: {e}")
-        
-        except FileNotFoundError:
-            print(f"File not found: {jsonl_file_path}")
-        
-        print(f"Loaded {success_count} questions into vector database")
-        return success_count
+    def get_system_info(self) -> Dict[str, Any]:
+        """Get information about available open-source models"""
+        return {
+            "available_models": self.model_manager.list_available_models(),
+            "total_models": len(self.model_manager.available_models),
+            "model_types": {
+                "groq_free_tier": [m for m in self.model_manager.list_available_models() if m.startswith("groq_")],
+                "ollama_local": [m for m in self.model_manager.list_available_models() if m.startswith("ollama_")],
+                "huggingface_local": [m for m in self.model_manager.list_available_models() if m.startswith("hf_")]
+            }
+        }
 
-def build_graph(provider: str | None = None) -> StateGraph:
-    """Build and return the graph for the enhanced agent system."""
-    return HybridLangGraphMultiLLMSystem(provider or "groq").graph
+# ---- Build Graph Function (for compatibility) ----
+def build_graph(provider: str = "opensource"):
+    """Build graph using only open-source models"""
+    return OpenSourceMultiLLMSystem().graph
 
+# ---- Main execution ----
 if __name__ == "__main__":
-    # Initialize and test the system
-    system = HybridLangGraphMultiLLMSystem()
+    # Initialize the open-source system
+    system = OpenSourceMultiLLMSystem()
     
-    # Load metadata if available
-    if os.path.exists("metadata.jsonl"):
-        system.load_metadata_from_jsonl("metadata.jsonl")
+    # Print system information
+    info = system.get_system_info()
+    print("Open-Source System Information:")
+    print(f"Total Models Available: {info['total_models']}")
+    for category, models in info['model_types'].items():
+        if models:
+            print(f"  {category}: {models}")
     
     # Test queries
     test_questions = [
-        "How many studio albums were published by Mercedes Sosa between 2000 and 2009?",
         "What is 25 multiplied by 17?",
-        "Find information about artificial intelligence on Wikipedia"
+        "Find information about Mercedes Sosa albums between 2000-2009",
+        "Write a simple Python function to calculate factorial",
+        "Explain quantum computing in simple terms",
+        "What is the capital of France?"
     ]
     
-    for question in test_questions:
-        print(f"Question: {question}")
+    print("\n" + "="*60)
+    print("Testing Open-Source Multi-LLM System")
+    print("="*60)
+    
+    for i, question in enumerate(test_questions, 1):
+        print(f"\nQuestion {i}: {question}")
+        print("-" * 50)
         answer = system.process_query(question)
         print(f"Answer: {answer}")
-        print("-" * 50)