Update app.py

app.py

@@ -1,30 +1,31 @@
 """LangGraph Agent with Gradio Interface"""
 import os
-import base64
-import gradio as gr
-import requests
-import pandas as pd
 from dotenv import load_dotenv
-import google.generativeai as genai
 from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition, ToolNode
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
 from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_community.tools import DuckDuckGoSearchResults
-from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-from langchain_community.vectorstores import Chroma
+from langchain_groq import ChatGroq
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+from langchain_community.vectorstores import SupabaseVectorStore
 from langchain_core.messages import SystemMessage, HumanMessage
 from langchain_core.tools import tool
 from langchain.tools.retriever import create_retriever_tool
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_openai import ChatOpenAI
-import ast  # Added missing import
-from typing import Dict, Any  # Added missing import
+from supabase.client import Client, create_client
+import json
+from typing import Literal
+from typing import TypedDict, Annotated, Sequence
+import operator
 
 # Load environment variables
 load_dotenv()
 
 # Setup API keys
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+HF_API_TOKEN = os.getenv("HF_API_TOKEN")
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 
 if GOOGLE_API_KEY:
@@ -32,328 +33,509 @@ if GOOGLE_API_KEY:
 else:
     print("Warning: GOOGLE_API_KEY not found")
 
-# Tool Definitions
+
 @tool
 def multiply(a: int, b: int) -> int:
-    """Multiply two numbers."""
+    """Multiply two numbers.
+    Args:
+        a: first int
+        b: second int
+    """
     return a * b
 
 @tool
 def add(a: int, b: int) -> int:
-    """Add two numbers."""
+    """Add two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
     return a + b
 
-@tool
-def modulus(a: int, b: int) -> int:
-    """Get the modulus of two numbers."""
-    return a % b
-
 @tool
 def subtract(a: int, b: int) -> int:
-    """Subtract two numbers."""
+    """Subtract two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
     return a - b
 
 @tool
 def divide(a: int, b: int) -> int:
-    """Divide two numbers."""
+    """Divide two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
     if b == 0:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
 @tool
-def arvix_search(query: str) -> str:
-    """Search Arxiv for a query and return maximum 3 results."""
-    try:
-        search_docs = ArxivLoader(query=query, load_max_docs=3).load()
-        formatted_search_docs = "\n\n---\n\n".join(
-            [f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content[:1000]}\n</Document>' 
-             for doc in search_docs])
-        return {"arvix_results": formatted_search_docs}
-    except Exception as e:
-        return {"arvix_results": f"Error: {str(e)}"}
-
-@tool
-def execute_python(code: str) -> str:
-    """Execute Python code securely and return results. Handles calculations and data analysis."""
-    try:
-        parsed = ast.parse(code)
-        if any(isinstance(node, (ast.Import, ast.ImportFrom)) for node in parsed.body):
-            return "Cannot import modules for security reasons"
-        
-        restricted_builtins = {'open', 'eval', 'exec', '__import__'}
-        for node in ast.walk(parsed):
-            if isinstance(node, ast.Name) and node.id in restricted_builtins:
-                return "Restricted function used"
-                
-        return str(eval(code, {"__builtins__": {}}, {}))
-    except Exception as e:
-        return f"Execution error: {str(e)}"
-
-@tool
-def process_file(file_path: str) -> Dict[str, Any]:
-    """Process uploaded files (Excel, CSV, TXT) and extract structured data."""
-    try:
-        if file_path.endswith(('.xlsx', '.xls')):
-            df = pd.read_excel(file_path)
-            return {"data": df.head(10).to_dict(), "summary": df.describe().to_dict()}
-        elif file_path.endswith('.csv'):
-            df = pd.read_csv(file_path)
-            return {"data": df.head(10).to_dict(), "summary": df.describe().to_dict()}
-        elif file_path.endswith('.txt'):
-            with open(file_path, 'r') as f:
-                content = f.read(2000)
-            return {"content": content}
-        return {"error": "Unsupported file format"}
-    except Exception as e:
-        return {"error": str(e)}
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b
 
 @tool
-def enhanced_wiki_search(query: str) -> str:
-    """Access full Wikipedia articles with history and specific versions."""
-    try:
-        loader = WikipediaLoader(query=query, load_max_docs=2, doc_content_chars_max=4000)
-        docs = loader.load()
-        return "\n\n".join([
-            f"Title: {doc.metadata['title']}\n"
-            f"URL: {doc.metadata['source']}\n"
-            f"Content: {doc.page_content[:3000]}..."
-            for doc in docs
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for a query and return maximum 2 results.
+    
+    Args:
+        query: The search query."""
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
         ])
-    except Exception as e:
-        return f"Wikipedia Error: {str(e)}"
+    return {"wiki_results": formatted_search_docs}
 
 @tool
-def media_search(query: str) -> str:
-    """Specialized search for media content (videos, images, celebrities)."""
-    try:
-        search = DuckDuckGoSearchResults(max_results=5)
-        results = search.invoke(f"site:imdb.com OR site:youtube.com {query}")
-        return "\n".join([
-            f"Source: {res['link']}\nSnippet: {res['snippet']}"
-            for res in results[:3]
+def web_search(query: str) -> str:
+    """Search Tavily for a query and return maximum 3 results.
+    
+    Args:
+        query: The search query."""
+    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
         ])
-    except Exception as e:
-        return f"Media Search Error: {str(e)}"
+    return {"web_results": formatted_search_docs}
 
 @tool
-def academic_search(query: str) -> str:
-    """Search academic databases and educational resources."""
-    try:
-        arxiv_docs = ArxivLoader(query=query, load_max_docs=2).load()
-        web_docs = DuckDuckGoSearchResults(max_results=3).invoke(f"filetype:pdf {query}")
-        return f"Arxiv Results:\n{arxiv_docs[0].page_content[:1000]}\n\nWeb Results:\n{web_docs[0]['snippet']}"
-    except Exception as e:
-        return f"Academic Search Error: {str(e)}"
+def arvix_search(query: str) -> str:
+    """Search Arxiv for a query and return maximum 3 result.
+    
+    Args:
+        query: The search query."""
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in search_docs
+        ])
+    return {"arvix_results": formatted_search_docs}
 
 
-@tool
-def web_search(query: str) -> str:
-    """Search DuckDuckGo for a query and return maximum 3 results."""
-    try:
-        search = DuckDuckGoSearchResults(max_results=3)
-        search_docs = search.invoke(query)
-        formatted_search_docs = "\n\n---\n\n".join(
-            [f'<Document source="{doc["link"]}"/>\n{doc["snippet"]}\n</Document>' 
-             for doc in search_docs])
-        return {"web_results": formatted_search_docs}
-    except Exception as e:
-        return {"web_results": f"Error: {str(e)}"}
 
-@tool
-def summarize_text(text: str) -> str:
-    """Summarize a long text into key points."""
-    if not text or len(text) < 100:
-        return "Text too short to summarize."
-    return f"Summary of the provided text with key points."
+# load the system prompt from the file
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
 
-@tool
-def parse_query(query: str) -> dict:
-    """Parse a complex query into its key components for better search."""
-    parts = query.split()
-    return {
-        "main_topic": parts[0] if parts else "",
-        "subtopics": parts[1:3] if len(parts) > 1 else [],
-        "context": " ".join(parts[3:]) if len(parts) > 3 else ""
-    }
-
-# System Prompt Setup
-system_prompt = """You are a POWERFUL assistant REQUIRED to answer ALL questions using available tools.
-STRICT RULES:
-1. NEVER say you can't answer - ALWAYS use tools
-2. Combine information from multiple tools when needed
-3. For calculations, use execute_python
-4. For files, use process_file
-5. For media/celebrities, use media_search
-6. For academic content, use academic_search
-7. ALWAYS format final answer as: FINAL ANSWER: [your answer]
-
-AVAILABLE TOOLS:
-- execute_python: Math/code execution
-- process_file: Analyze uploaded files
-- enhanced_wiki_search: Full Wikipedia access
-- media_search: Videos/images/celebrities
-- academic_search: Textbooks/papers
-- web_search: General web search
-- vector_store: Previous knowledge
-
-YOU MUST USE THESE TOOLS TO ANSWER ALL QUESTIONS!"""
+# System message
 sys_msg = SystemMessage(content=system_prompt)
 
-# Vector Store Setup
-try:
-    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-    vector_store = Chroma(
-        collection_name="documents",
-        embedding_function=embeddings,
-        persist_directory="./chroma_db"
-    )
-except Exception as e:
-    print(f"Error initializing vector store: {e}")
-    vector_store = None
+# build a retriever
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2") #  dim=768
+supabase: Client = create_client(
+    os.environ.get("SUPABASE_URL"), 
+    os.environ.get("SUPABASE_SERVICE_KEY"))
+vector_store = SupabaseVectorStore(
+    client=supabase,
+    embedding= embeddings,
+    table_name="documents",
+    query_name="match_documents_langchain",
+)
+create_retriever_tool = create_retriever_tool(
+    retriever=vector_store.as_retriever(),
+    name="Question Search",
+    description="A tool to retrieve similar questions from a vector store.",
+)
 
-# Tool Configuration
 tools = [
-    multiply, add, subtract, divide, modulus,
-    enhanced_wiki_search, media_search, web_search, arvix_search,
-    academic_search, summarize_text, parse_query, DuckDuckGoSearchResults(max_results=5)
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    wiki_search,
+    web_search,
+    arvix_search,
 ]
 
-if vector_store:
-    tools.append(
-        create_retriever_tool(
-            vector_store.as_retriever(),
-            name="Question Search",
-            description="Retrieves similar questions from vector store"
+# Build graph function
+def build_graph(provider: str = "google"):
+    """Build the graph"""
+    # Load environment variables from .env file
+    if provider == "google":
+        # Google Gemini
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+    elif provider == "huggingface":
+        # TODO: Add huggingface endpoint
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                url="https://api-inference.huggingface.co/models/Meta-DeepLearning/llama-2-7b-chat-hf",
+                temperature=0,
+            ),
         )
+    else:
+        raise ValueError("Invalid provider. Choose 'google', or 'huggingface'.")
+    # Bind tools to LLM
+    llm_with_tools = llm.bind_tools(tools)
+
+    # Node
+    def assistant(state: MessagesState):
+        """Assistant node"""
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+    
+    def retriever(state: MessagesState):
+        """Retriever node"""
+        similar_question = vector_store.similarity_search(state["messages"][0].content)
+        example_msg = HumanMessage(
+            content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+        )
+        return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("retriever", retriever)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_edge(START, "retriever")
+    builder.add_edge("retriever", "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        tools_condition,
     )
+    builder.add_edge("tools", "assistant")
 
-# Model Configuration
-MODEL_REGISTRY = {
-    "gemini-2.0-flash": {
-        "provider": "google",
-        "model": "gemini-2.0-flash",
-        "temperature": 0.2,
-        "max_tokens": 2048
-    },
-    "gemini-1.5-flash": {
-        "provider": "google",
-        "model": "gemini-1.5-flash", 
-        "temperature": 0.2,
-        "max_tokens": 2048
-    },
-    "kimi-vl-a3b-thinking": {
-        "provider": "openrouter",
-        "model": "moonshotai/kimi-vl-a3b-thinking:free",
-        "temperature": 0.2,
-        "max_tokens": 2048
-    }
-}
-
-def get_llm(model_name: str = "gemini-2.0-flash"):
-    """Initialize LLM with error handling"""
-    config = MODEL_REGISTRY.get(model_name, MODEL_REGISTRY["gemini-2.0-flash"])
-    provider = config.get("provider", "google")
+    # Compile graph
+    return builder.compile()
+
+
+
+# Tool Definitions
+# @tool
+# def multiply(a: int, b: int) -> int:
+#     """Multiply two numbers."""
+#     return a * b
+
+# @tool
+# def add(a: int, b: int) -> int:
+#     """Add two numbers."""
+#     return a + b
+
+# @tool
+# def modulus(a: int, b: int) -> int:
+#     """Get the modulus of two numbers."""
+#     return a % b
+
+# @tool
+# def subtract(a: int, b: int) -> int:
+#     """Subtract two numbers."""
+#     return a - b
+
+# @tool
+# def divide(a: int, b: int) -> int:
+#     """Divide two numbers."""
+#     if b == 0:
+#         raise ValueError("Cannot divide by zero.")
+#     return a / b
+
+# @tool
+# def arvix_search(query: str) -> str:
+#     """Search Arxiv for a query and return maximum 3 results."""
+#     try:
+#         search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+#         formatted_search_docs = "\n\n---\n\n".join(
+#             [f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content[:1000]}\n</Document>' 
+#              for doc in search_docs])
+#         return {"arvix_results": formatted_search_docs}
+#     except Exception as e:
+#         return {"arvix_results": f"Error: {str(e)}"}
+
+# @tool
+# def execute_python(code: str) -> str:
+#     """Execute Python code securely and return results. Handles calculations and data analysis."""
+#     try:
+#         parsed = ast.parse(code)
+#         if any(isinstance(node, (ast.Import, ast.ImportFrom)) for node in parsed.body):
+#             return "Cannot import modules for security reasons"
+        
+#         restricted_builtins = {'open', 'eval', 'exec', '__import__'}
+#         for node in ast.walk(parsed):
+#             if isinstance(node, ast.Name) and node.id in restricted_builtins:
+#                 return "Restricted function used"
+                
+#         return str(eval(code, {"__builtins__": {}}, {}))
+#     except Exception as e:
+#         return f"Execution error: {str(e)}"
+
+# @tool
+# def process_file(file_path: str) -> Dict[str, Any]:
+#     """Process uploaded files (Excel, CSV, TXT) and extract structured data."""
+#     try:
+#         if file_path.endswith(('.xlsx', '.xls')):
+#             df = pd.read_excel(file_path)
+#             return {"data": df.head(10).to_dict(), "summary": df.describe().to_dict()}
+#         elif file_path.endswith('.csv'):
+#             df = pd.read_csv(file_path)
+#             return {"data": df.head(10).to_dict(), "summary": df.describe().to_dict()}
+#         elif file_path.endswith('.txt'):
+#             with open(file_path, 'r') as f:
+#                 content = f.read(2000)
+#             return {"content": content}
+#         return {"error": "Unsupported file format"}
+#     except Exception as e:
+#         return {"error": str(e)}
+
+# @tool
+# def enhanced_wiki_search(query: str) -> str:
+#     """Access full Wikipedia articles with history and specific versions."""
+#     try:
+#         loader = WikipediaLoader(query=query, load_max_docs=2, doc_content_chars_max=4000)
+#         docs = loader.load()
+#         return "\n\n".join([
+#             f"Title: {doc.metadata['title']}\n"
+#             f"URL: {doc.metadata['source']}\n"
+#             f"Content: {doc.page_content[:3000]}..."
+#             for doc in docs
+#         ])
+#     except Exception as e:
+#         return f"Wikipedia Error: {str(e)}"
+
+# @tool
+# def media_search(query: str) -> str:
+#     """Specialized search for media content (videos, images, celebrities)."""
+#     try:
+#         search = DuckDuckGoSearchResults(max_results=5)
+#         results = search.invoke(f"site:imdb.com OR site:youtube.com {query}")
+#         return "\n".join([
+#             f"Source: {res['link']}\nSnippet: {res['snippet']}"
+#             for res in results[:3]
+#         ])
+#     except Exception as e:
+#         return f"Media Search Error: {str(e)}"
+
+# @tool
+# def academic_search(query: str) -> str:
+#     """Search academic databases and educational resources."""
+#     try:
+#         arxiv_docs = ArxivLoader(query=query, load_max_docs=2).load()
+#         web_docs = DuckDuckGoSearchResults(max_results=3).invoke(f"filetype:pdf {query}")
+#         return f"Arxiv Results:\n{arxiv_docs[0].page_content[:1000]}\n\nWeb Results:\n{web_docs[0]['snippet']}"
+#     except Exception as e:
+#         return f"Academic Search Error: {str(e)}"
+
+
+# @tool
+# def web_search(query: str) -> str:
+#     """Search DuckDuckGo for a query and return maximum 3 results."""
+#     try:
+#         search = DuckDuckGoSearchResults(max_results=3)
+#         search_docs = search.invoke(query)
+#         formatted_search_docs = "\n\n---\n\n".join(
+#             [f'<Document source="{doc["link"]}"/>\n{doc["snippet"]}\n</Document>' 
+#              for doc in search_docs])
+#         return {"web_results": formatted_search_docs}
+#     except Exception as e:
+#         return {"web_results": f"Error: {str(e)}"}
+
+# @tool
+# def summarize_text(text: str) -> str:
+#     """Summarize a long text into key points."""
+#     if not text or len(text) < 100:
+#         return "Text too short to summarize."
+#     return f"Summary of the provided text with key points."
+
+# @tool
+# def parse_query(query: str) -> dict:
+#     """Parse a complex query into its key components for better search."""
+#     parts = query.split()
+#     return {
+#         "main_topic": parts[0] if parts else "",
+#         "subtopics": parts[1:3] if len(parts) > 1 else [],
+#         "context": " ".join(parts[3:]) if len(parts) > 3 else ""
+#     }
+
+# # System Prompt Setup
+# system_prompt = """You are a POWERFUL assistant REQUIRED to answer ALL questions using available tools.
+# STRICT RULES:
+# 1. NEVER say you can't answer - ALWAYS use tools
+# 2. Combine information from multiple tools when needed
+# 3. For calculations, use execute_python
+# 4. For files, use process_file
+# 5. For media/celebrities, use media_search
+# 6. For academic content, use academic_search
+# 7. ALWAYS format final answer as: FINAL ANSWER: [your answer]
+
+# AVAILABLE TOOLS:
+# - execute_python: Math/code execution
+# - process_file: Analyze uploaded files
+# - enhanced_wiki_search: Full Wikipedia access
+# - media_search: Videos/images/celebrities
+# - academic_search: Textbooks/papers
+# - web_search: General web search
+# - vector_store: Previous knowledge
+
+# YOU MUST USE THESE TOOLS TO ANSWER ALL QUESTIONS!"""
+# sys_msg = SystemMessage(content=system_prompt)
+
+# # Vector Store Setup
+# try:
+#     embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
+#     vector_store = Chroma(
+#         collection_name="documents",
+#         embedding_function=embeddings,
+#         persist_directory="./chroma_db"
+#     )
+# except Exception as e:
+#     print(f"Error initializing vector store: {e}")
+#     vector_store = None
+
+# # Tool Configuration
+# tools = [
+#     multiply, add, subtract, divide, modulus,
+#     enhanced_wiki_search, media_search, web_search, arvix_search,
+#     academic_search, summarize_text, parse_query, DuckDuckGoSearchResults(max_results=5)
+# ]
+
+# if vector_store:
+#     tools.append(
+#         create_retriever_tool(
+#             vector_store.as_retriever(),
+#             name="Question Search",
+#             description="Retrieves similar questions from vector store"
+#         )
+#     )
+
+# # Model Configuration
+# MODEL_REGISTRY = {
+#     "gemini-2.0-flash": {
+#         "provider": "google",
+#         "model": "gemini-2.0-flash",
+#         "temperature": 0.2,
+#         "max_tokens": 2048
+#     },
+#     "gemini-1.5-flash": {
+#         "provider": "google",
+#         "model": "gemini-1.5-flash", 
+#         "temperature": 0.2,
+#         "max_tokens": 2048
+#     },
+#     "kimi-vl-a3b-thinking": {
+#         "provider": "openrouter",
+#         "model": "moonshotai/kimi-vl-a3b-thinking:free",
+#         "temperature": 0.2,
+#         "max_tokens": 2048
+#     }
+# }
+
+# def get_llm(model_name: str = "gemini-2.0-flash"):
+#     """Initialize LLM with error handling"""
+#     config = MODEL_REGISTRY.get(model_name, MODEL_REGISTRY["gemini-2.0-flash"])
+#     provider = config.get("provider", "google")
     
-    try:
-        if provider == "google":
-            if not GOOGLE_API_KEY:
-                print(f"Error initializing {model_name}: GOOGLE_API_KEY not found")
-                return None
-            return ChatGoogleGenerativeAI(
-                model=config["model"],
-                temperature=config["temperature"],
-                max_output_tokens=config["max_tokens"],
-                convert_system_message_to_human=True
-            )
-        elif provider == "openrouter":
-            if not OPENROUTER_API_KEY:
-                print(f"Error initializing {model_name}: OPENROUTER_API_KEY not found")
-                return None
-            return ChatOpenAI(
-                model=config["model"],
-                temperature=config["temperature"],
-                max_tokens=config["max_tokens"],
-                openai_api_key=OPENROUTER_API_KEY,
-                openai_api_base="https://openrouter.ai/api/v1",
-                model_kwargs={
-                    "headers": {
-                        "HTTP-Referer": "https://your-site.com",
-                        "X-Title": "Agent Evaluation"
-                    }
-                }
-            )
-        else:
-            print(f"Unknown provider {provider} for model {model_name}")
-            return None
-    except Exception as e:
-        print(f"Error initializing {model_name}: {e}")
-        return None
-
-# Graph Builder
-def build_graph():
-    """Build LangGraph agent workflow"""
-    primary_llm = get_llm("gemini-2.0-flash")
-    fallback_llm = get_llm("gemini-1.5-flash")
-    kimi_llm = get_llm("kimi-vl-a3b-thinking")
+#     try:
+#         if provider == "google":
+#             if not GOOGLE_API_KEY:
+#                 print(f"Error initializing {model_name}: GOOGLE_API_KEY not found")
+#                 return None
+#             return ChatGoogleGenerativeAI(
+#                 model=config["model"],
+#                 temperature=config["temperature"],
+#                 max_output_tokens=config["max_tokens"],
+#                 convert_system_message_to_human=True
+#             )
+#         elif provider == "openrouter":
+#             if not OPENROUTER_API_KEY:
+#                 print(f"Error initializing {model_name}: OPENROUTER_API_KEY not found")
+#                 return None
+#             return ChatOpenAI(
+#                 model=config["model"],
+#                 temperature=config["temperature"],
+#                 max_tokens=config["max_tokens"],
+#                 openai_api_key=OPENROUTER_API_KEY,
+#                 openai_api_base="https://openrouter.ai/api/v1",
+#                 model_kwargs={
+#                     "headers": {
+#                         "HTTP-Referer": "https://your-site.com",
+#                         "X-Title": "Agent Evaluation"
+#                     }
+#                 }
+#             )
+#         else:
+#             print(f"Unknown provider {provider} for model {model_name}")
+#             return None
+#     except Exception as e:
+#         print(f"Error initializing {model_name}: {e}")
+#         return None
+
+# # Graph Builder
+# def build_graph():
+#     """Build LangGraph agent workflow"""
+#     primary_llm = get_llm("gemini-2.0-flash")
+#     fallback_llm = get_llm("gemini-1.5-flash")
+#     kimi_llm = get_llm("kimi-vl-a3b-thinking")
     
-    llms = [llm for llm in [primary_llm, fallback_llm, kimi_llm] if llm is not None]
+#     llms = [llm for llm in [primary_llm, fallback_llm, kimi_llm] if llm is not None]
     
-    if not llms:
-        raise RuntimeError("Failed to initialize any LLM")
+#     if not llms:
+#         raise RuntimeError("Failed to initialize any LLM")
 
-    current_llm_index = 0
+#     current_llm_index = 0
 
-    def assistant(state: MessagesState):
-        nonlocal current_llm_index
-        for attempt in range(len(llms)):
-            try:
-                llm = llms[current_llm_index]
-                llm_with_tools = llm.bind_tools(tools)
+#     def assistant(state: MessagesState):
+#         nonlocal current_llm_index
+#         for attempt in range(len(llms)):
+#             try:
+#                 llm = llms[current_llm_index]
+#                 llm_with_tools = llm.bind_tools(tools)
                 
-                messages = state["messages"].copy()
-                if len(messages) > 0 and isinstance(messages[0], HumanMessage):
-                    tool_instruction = HumanMessage(content="Use available tools to answer.")
-                    messages.append(tool_instruction)
+#                 messages = state["messages"].copy()
+#                 if len(messages) > 0 and isinstance(messages[0], HumanMessage):
+#                     tool_instruction = HumanMessage(content="Use available tools to answer.")
+#                     messages.append(tool_instruction)
                 
-                response = llm_with_tools.invoke(messages)
-                current_llm_index = (current_llm_index + 1) % len(llms)
-                return {"messages": [response]}
-            except Exception as e:
-                print(f"Model {llms[current_llm_index]} failed: {e}")
-                current_llm_index = (current_llm_index + 1) % len(llms)
-                if attempt == len(llms) - 1:
-                    error_msg = HumanMessage(content=f"All models failed: {str(e)}")
-                    return {"messages": [error_msg]}
-
-    def retriever(state: MessagesState):
-        try:
-            if vector_store:
-                similar_questions = vector_store.similarity_search(
-                    state["messages"][0].content,
-                    k=1
-                )
-                example_content = "Similar question reference: \n\n" + \
-                    (similar_questions[0].page_content if similar_questions 
-                     else "No similar questions found")
-            else:
-                example_content = "Vector store not available"
+#                 response = llm_with_tools.invoke(messages)
+#                 current_llm_index = (current_llm_index + 1) % len(llms)
+#                 return {"messages": [response]}
+#             except Exception as e:
+#                 print(f"Model {llms[current_llm_index]} failed: {e}")
+#                 current_llm_index = (current_llm_index + 1) % len(llms)
+#                 if attempt == len(llms) - 1:
+#                     error_msg = HumanMessage(content=f"All models failed: {str(e)}")
+#                     return {"messages": [error_msg]}
+
+#     def retriever(state: MessagesState):
+#         try:
+#             if vector_store:
+#                 similar_questions = vector_store.similarity_search(
+#                     state["messages"][0].content,
+#                     k=1
+#                 )
+#                 example_content = "Similar question reference: \n\n" + \
+#                     (similar_questions[0].page_content if similar_questions 
+#                      else "No similar questions found")
+#             else:
+#                 example_content = "Vector store not available"
             
-            return {"messages": [sys_msg] + state["messages"] + [HumanMessage(content=example_content)]}
-        except Exception as e:
-            error_msg = HumanMessage(content=f"Retrieval error: {str(e)}")
-            return {"messages": [error_msg]}
+#             return {"messages": [sys_msg] + state["messages"] + [HumanMessage(content=example_content)]}
+#         except Exception as e:
+#             error_msg = HumanMessage(content=f"Retrieval error: {str(e)}")
+#             return {"messages": [error_msg]}
 
-    builder = StateGraph(MessagesState)
-    builder.add_node("retriever", retriever)
-    builder.add_node("assistant", assistant)
-    builder.add_node("tools", ToolNode(tools))
+#     builder = StateGraph(MessagesState)
+#     builder.add_node("retriever", retriever)
+#     builder.add_node("assistant", assistant)
+#     builder.add_node("tools", ToolNode(tools))
     
-    builder.add_edge(START, "retriever")
-    builder.add_edge("retriever", "assistant")
-    builder.add_conditional_edges("assistant", tools_condition)
-    builder.add_edge("tools", "assistant")
+#     builder.add_edge(START, "retriever")
+#     builder.add_edge("retriever", "assistant")
+#     builder.add_conditional_edges("assistant", tools_condition)
+#     builder.add_edge("tools", "assistant")
     
-    return builder.compile()
+#     return builder.compile()
 
 # Agent Class
 class BasicAgent: