changes for adding support for llamaindex agent

agents.py

@@ -3,6 +3,7 @@
 import config
 from langgraphagent import LangGraphAgent
 from reactlanggraphagent import ReActLangGraphAgent
+from llamaindexagent import LlamaIndexAgent
 
 
 class MyGAIAAgents:
@@ -26,6 +27,8 @@ class MyGAIAAgents:
             self.agent = LangGraphAgent()
         elif active_agent == config.AGENT_REACT_LANGGRAPH:
             self.agent = ReActLangGraphAgent()
+        elif active_agent == config.AGENT_LLAMAINDEX:
+            self.agent = LlamaIndexAgent()
         else:
             # Default to LangGraph if unknown agent type
             print(f"[WARNING] Unknown agent type '{active_agent}', defaulting to {config.AGENT_LANGGRAPH}")

config.py

@@ -42,6 +42,8 @@ GEMINI_MODEL = "gemini-2.5-flash"
 GEMINI_TEMPERATURE = 0
 GEMINI_MAX_TOKENS = 1024
 
+ACTIVE_AGENT_LLM_MODEL = GEMINI_MODEL
+
 # Retry Configuration for 504 DEADLINE_EXCEEDED errors
 MAX_RETRIES = 3
 INITIAL_RETRY_DELAY = 2.0  # seconds

gradioapp.py

@@ -26,6 +26,10 @@ def _run_and_submit_react(profile: gr.OAuthProfile | None = None):
     """Run and submit with ReActLangGraph agent."""
     return _run_and_submit_all_local(profile, active_agent=config.AGENT_REACT_LANGGRAPH)
 
+def _run_and_submit_llamaindex(profile: gr.OAuthProfile | None = None):
+    """Run and submit with LlamaIndex agent."""
+    return _run_and_submit_all_local(profile, active_agent=config.AGENT_LLAMAINDEX)
+
 
 def create_ui(run_and_submit_all, run_test_code):
     """Create the Main App with custom layout to include LoginButton"""
@@ -56,6 +60,7 @@ def create_ui(run_and_submit_all, run_test_code):
         with gr.Row():
             run_button_langgraph = gr.Button("Run with LangGraph Agent", variant="primary")
             run_button_react = gr.Button("Run with ReAct Agent", variant="secondary")
+            run_button_llamaindex = gr.Button("Run with LlamaIndex Agent", variant="secondary")
 
         status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
         # Removed max_rows=10 from DataFrame constructor
@@ -70,6 +75,11 @@ def create_ui(run_and_submit_all, run_test_code):
             fn=_run_and_submit_react,
             outputs=[status_output, results_table]
         )
+
+        run_button_llamaindex.click(
+            fn=_run_and_submit_llamaindex,
+            outputs=[status_output, results_table]
+        )
         
         test_button = gr.Button("Run Test Examples")
         test_results_table = gr.DataFrame(label="Test Answers from Agent", wrap=True)

langgraphagent.py

@@ -58,7 +58,7 @@ class LangGraphAgent:
             apikey = os.getenv("GOOGLE_API_KEY")
 
             return ChatGoogleGenerativeAI(
-                model="gemini-2.5-flash",  # Changed from gemini-2.5-flash-lite - better tool calling
+                model=config.ACTIVE_AGENT_LLM_MODEL,
                 temperature=0,
                 api_key=apikey,
                 timeout=60  # Add timeout to prevent hanging

llamaindexagent.py

@@ -0,0 +1,194 @@
+import os
+import logging
+import warnings
+import time
+import asyncio
+import nest_asyncio
+
+# Apply nest_asyncio to allow nested event loops
+nest_asyncio.apply()
+
+# Suppress TensorFlow/Keras warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+warnings.filterwarnings('ignore', module='tensorflow')
+warnings.filterwarnings('ignore', module='tf_keras')
+
+from llama_index.core.agent import ReActAgent
+from llama_index.llms.gemini import Gemini
+from llama_index.core.tools import FunctionTool
+
+from custom_tools import get_custom_tools_list
+from system_prompt import SYSTEM_PROMPT
+from utils import cleanup_answer, extract_text_from_content
+import config
+
+# Suppress BeautifulSoup GuessedAtParserWarning
+try:
+    from bs4 import GuessedAtParserWarning
+    warnings.filterwarnings('ignore', category=GuessedAtParserWarning)
+except ImportError:
+    pass
+
+
+class LlamaIndexAgent:
+    """
+    LlamaIndex agent implementation using ReActAgent.
+
+    This agent uses LlamaIndex's ReAct agent pattern which integrates
+    with various LLM providers and tools. It provides an alternative
+    implementation to LangGraph-based agents.
+    """
+
+    def __init__(self):
+        # Validate API keys
+        if not os.getenv("GOOGLE_API_KEY"):
+            print("WARNING: GOOGLE_API_KEY not found - analyze_youtube_video will fail")
+
+        self.langchain_tools = get_custom_tools_list()
+        self.llm = self._create_llm_client()
+        self.tools = self._convert_tools_to_llamaindex()
+        self.agent = self._build_agent()
+
+    def _create_llm_client(self):
+        """Create and return the LLM client for LlamaIndex."""
+        api_key = os.getenv("GOOGLE_API_KEY")
+
+        # Create Gemini LLM for LlamaIndex
+        llm = Gemini(
+            model=config.ACTIVE_AGENT_LLM_MODEL,
+            api_key=api_key,
+            temperature=config.GEMINI_TEMPERATURE,
+            max_tokens=config.GEMINI_MAX_TOKENS,
+        )
+
+        return llm
+
+    def _convert_tools_to_llamaindex(self) -> list[FunctionTool]:
+        """Convert LangChain tools to LlamaIndex FunctionTool format."""
+        llamaindex_tools = []
+
+        for langchain_tool in self.langchain_tools:
+            # Extract the function from LangChain tool
+            tool_func = langchain_tool.func if hasattr(langchain_tool, 'func') else langchain_tool
+
+            # Create LlamaIndex FunctionTool
+            llamaindex_tool = FunctionTool.from_defaults(
+                fn=tool_func,
+                name=langchain_tool.name,
+                description=langchain_tool.description,
+            )
+
+            llamaindex_tools.append(llamaindex_tool)
+
+        return llamaindex_tools
+
+    def _build_agent(self) -> ReActAgent:
+        """Build and return the LlamaIndex ReAct agent."""
+
+        # Create ReAct agent with tools and LLM
+        agent = ReActAgent(
+            tools=self.tools,
+            llm=self.llm,
+            verbose=True,
+            max_iterations=40,  # Match the step limit from other agents
+            system_prompt=SYSTEM_PROMPT,
+        )
+
+        return agent
+
+    def __call__(self, question: str, file_name: str = None) -> str:
+        """
+        Invoke the LlamaIndex agent with the given question and return the final answer.
+
+        Args:
+            question: The question to answer
+            file_name: Optional file name if the question references a file
+
+        Returns:
+            The agent's answer as a string
+        """
+        print(f"\n{'='*60}")
+        print(f"[LLAMAINDEX AGENT START] Question: {question}")
+        if file_name:
+            print(f"[FILE] {file_name}")
+        print(f"{'='*60}")
+
+        start_time = time.time()
+
+        try:
+            # Build the question with file name if provided
+            question_content = question
+            if file_name:
+                question_content += f'\n\nNote: This question references a file: {file_name}'
+
+            # Invoke the agent with retry logic for 504 errors
+            max_retries = config.MAX_RETRIES
+            delay = config.INITIAL_RETRY_DELAY
+
+            for attempt in range(max_retries + 1):
+                try:
+                    # Create a dedicated async function to run the agent
+                    async def run_agent_async():
+                        return await self.agent.run(question_content)
+
+                    # Try different approaches to run the async function
+                    try:
+                        # Check if a loop is already running
+                        asyncio.get_running_loop()
+                        # If we reach here, a loop is already running
+                        # Run in a separate thread to avoid "event loop already running" error
+                        import concurrent.futures
+                        with concurrent.futures.ThreadPoolExecutor() as executor:
+                            response = executor.submit(
+                                lambda: asyncio.run(run_agent_async())
+                            ).result()
+                    except RuntimeError:
+                        # No running loop, we can use asyncio.run directly
+                        response = asyncio.run(run_agent_async())
+
+                    # Success - break out of retry loop
+                    break
+                except Exception as e:
+                    error_msg = str(e)
+
+                    # Check if this is a 504 DEADLINE_EXCEEDED error
+                    if "504" in error_msg and "DEADLINE_EXCEEDED" in error_msg:
+                        if attempt < max_retries:
+                            print(f"[RETRY] Attempt {attempt + 1}/{max_retries} failed with 504 DEADLINE_EXCEEDED")
+                            print(f"[RETRY] Retrying in {delay:.1f} seconds...")
+                            time.sleep(delay)
+                            delay *= config.RETRY_BACKOFF_FACTOR
+                            continue
+                        else:
+                            print(f"[RETRY] All {max_retries} retries exhausted for 504 error")
+                            print(f"[ERROR] Agent invocation failed after retries: {e}")
+                            return f"Error: Agent failed after {max_retries} retries - {str(e)[:100]}"
+                    else:
+                        # Not a 504 error - fail immediately without retry
+                        print(f"[ERROR] Agent invocation failed: {e}")
+                        return f"Error: Agent failed - {str(e)[:100]}"
+
+            elapsed_time = time.time() - start_time
+            print(f"[LLAMAINDEX AGENT COMPLETE] Time: {elapsed_time:.2f}s")
+            print(f"{'='*60}\n")
+
+            # Extract the answer from the response using utility function
+            # This handles ChatMessage objects, dicts, lists, and strings
+            answer = extract_text_from_content(response)
+
+            if not answer or answer is None:
+                print("[WARNING] Agent completed but returned Empty answer")
+                return "Error: No answer generated"
+
+            # Clean up the answer using utility function (includes stripping)
+            answer = cleanup_answer(answer)
+
+            print(f"[FINAL ANSWER] {answer}")
+            return answer
+
+        except Exception as e:
+            elapsed_time = time.time() - start_time
+            print(f"[LLAMAINDEX AGENT ERROR] Failed after {elapsed_time:.2f}s: {e}")
+            print(f"{'='*60}\n")
+            return f"Error: {str(e)[:100]}"

reactlanggraphagent.py

@@ -49,7 +49,7 @@ class ReActLangGraphAgent:
         apikey = os.getenv("GOOGLE_API_KEY")
 
         return ChatGoogleGenerativeAI(
-            model=config.GEMINI_MODEL,
+            model=config.ACTIVE_AGENT_LLM_MODEL,
             temperature=config.GEMINI_TEMPERATURE,
             api_key=apikey,
             timeout=60

requirements.txt

@@ -12,6 +12,9 @@ langchain-core
 langchain-google-genai
 langchain-huggingface
 langchain-community
+llama-index
+llama-index-llms-gemini
+llama-index-core
 pypdf
 youtube-transcript-api
 pytube

utils.py

@@ -53,6 +53,7 @@ def extract_text_from_content(content: Any) -> str:
     Extract plain text from various content formats returned by LLM agents.
 
     This function handles multiple content formats:
+    - ChatMessage objects (LlamaIndex): Extracts the content attribute
     - String: Returns as-is
     - Dict with 'text' field: Extracts the text value
     - List of content blocks: Extracts text from all blocks with type='text'
@@ -64,6 +65,16 @@ def extract_text_from_content(content: Any) -> str:
     Returns:
         str: Extracted plain text content
     """
+    # Handle LlamaIndex ChatMessage objects
+    try:
+        from llama_index.core.base.llms.types import ChatMessage
+        if isinstance(content, ChatMessage):
+            # Extract just the content attribute (without role prefix)
+            return str(content.content)
+    except ImportError:
+        # LlamaIndex not installed, skip this check
+        pass
+
     # Handle dict format (e.g., {'text': 'answer'})
     if isinstance(content, dict):
         if 'text' in content: