Update app.py

app.py

@@ -1,214 +1,20 @@
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
-import datetime
-import requests
-import pytz
-import yaml
-import json
 import gradio as gr
-
-# Import additional tools
-from tools.final_answer import FinalAnswerTool
-from Gradio_UI import GradioUI
+from tools.perplexity_tools import (
+    get_ai_research_papers,
+    summarize_paper,
+    get_citation,
+    explain_concept,
+)
+from tools.general_tools import initialize_perplexity
 
 # Initialize Perplexity without API key and model
 perplexity_api_key = None
 perplexity_model = "sonar-pro"  # Default model
 
-@tool
-def initialize_perplexity(api_key: str, model: str) -> str:
-    """Initialize Perplexity API with your API key and model.
-    Args:
-        api_key: Your Perplexity API key
-        model: The Perplexity model to use
-    """
-    global perplexity_api_key, perplexity_model
-    perplexity_api_key = api_key
-    perplexity_model = model
-    return f"Perplexity API initialized successfully with model: {model}!"
-
-def call_perplexity_api(query: str):
-    """Calls the Perplexity API with the provided query and parameters."""
-    global perplexity_api_key, perplexity_model
-    if not perplexity_api_key:
-        return "Error: Perplexity API not initialized. Please initialize it first."
-    
-    url = "https://api.perplexity.ai/chat/completions"
-    
-    # System prompt
-    system_prompt = """
-    You are a helpful AI assistant.
-
-    Rules:
-    1. Provide only the final answer. It is important that you do not include any explanation on the steps below.
-    2. Do not show the intermediate steps information.
-
-    Steps:
-    1. Decide if the answer should be a brief sentence or a list of suggestions.
-    2. If it is a list of suggestions, first, write a brief and natural introduction based on the original query.
-    3. Followed by a list of suggestions, each suggestion should be split by two newlines.
-    """
-    
-    payload = {
-        "model": perplexity_model,  # Use the selected model
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt.strip()  # Add the system prompt
-            },
-            {
-                "role": "user",
-                "content": query
-            }
-        ],
-        "max_tokens": 8000 if perplexity_model in ["sonar-reasoning-pro", "sonar-pro"] else 1000,
-        "temperature": 0.2,
-        "top_p": 0.9,
-        "search_domain_filter": None,
-        "return_images": False,
-        "return_related_questions": False,
-        "search_recency_filter": "month",  # Limit recency of search to this month
-        "top_k": 0,
-        "stream": False,
-        "presence_penalty": 0,
-        "frequency_penalty": 1,
-        "response_format": None
-    }
-    headers = {
-        "Authorization": f"Bearer {perplexity_api_key}",
-        "Content-Type": "application/json"
-    }
-    
-    try:
-        response = requests.post(url, json=payload, headers=headers)
-        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
-        return response.json()  # Return the JSON response
-    except requests.exceptions.RequestException as e:
-        # Provide detailed error information
-        error_details = {
-            "error_type": type(e).__name__,
-            "error_message": str(e),
-            "response_status_code": getattr(e.response, "status_code", None),
-            "response_text": getattr(e.response, "text", None),
-            "request_payload": payload,
-            "request_headers": headers
-        }
-        return f"Request failed. Details:\n{json.dumps(error_details, indent=2)}"
-
-@tool
-def get_ai_research_papers(query: str) -> str:
-    """A tool that fetches relevant AI research papers using Perplexity API.
-    Args:
-        query: The search query for AI research papers.
-    """
-    try:
-        response_json = call_perplexity_api(f"search AI research papers about: {query}")
-        if isinstance(response_json, str):  # Error message
-            return response_json
-        
-        if response_json and "choices" in response_json:
-            content = response_json["choices"][0]["message"]["content"]
-            citations = response_json.get("citations", [])
-            citation_string = "\n".join([f"{i+1}. {citation}" for i, citation in enumerate(citations)])
-            
-            return f"AI Research Papers:\n{content}\n\nCitations:\n{citation_string if citation_string else 'No citations found.'}"
-            
-        return f"No relevant AI papers found for your query: {query}"
-    except Exception as e:
-        return f"Error fetching research papers: {str(e)}"
-
-@tool
-def summarize_paper(paper_title: str) -> str:
-    """A tool that summarizes an AI research paper.
-    Args:
-        paper_title: Title of the paper to summarize.
-    """
-    try:
-        response_json = call_perplexity_api(f"Summarize AI research paper: {paper_title}")
-        if isinstance(response_json, str):  # Error message
-            return response_json
-        
-        if response_json and "choices" in response_json:
-            content = response_json["choices"][0]["message"]["content"]
-            return f"Summary of '{paper_title}':\n{content}"
-        return f"Could not summarize paper '{paper_title}'"
-    except Exception as e:
-        return f"Error summarizing paper: {str(e)}"
-
-@tool
-def get_citation(paper_title: str) -> str:
-    """A tool that generates a citation for an AI research paper.
-    Args:
-        paper_title: Title of the paper to cite.
-    """
-    try:
-        response_json = call_perplexity_api(f"Generate citation for AI research paper: {paper_title}")
-        if isinstance(response_json, str):  # Error message
-            return response_json
-         
-        if response_json and "choices" in response_json:
-            content = response_json["choices"][0]["message"]["content"]
-            return f"Citation for '{paper_title}':\n{content}"
-        return f"Could not generate citation for '{paper_title}'"
-    except Exception as e:
-        return f"Error generating citation: {str(e)}"
-
-@tool
-def explain_concept(concept: str) -> str:
-    """A tool that explains an AI-related concept in simple terms.
-    Args:
-        concept: The concept to explain.
-    """
-    try:
-        response_json = call_perplexity_api(f"Explain the AI concept: {concept}")
-        if isinstance(response_json, str):  # Error message
-            return response_json
-         
-        if response_json and "choices" in response_json:
-            content = response_json["choices"][0]["message"]["content"]
-            return f"Explanation of {concept}:\n{content}"
-        return f"Could not explain the concept '{concept}'"
-    except Exception as e:
-        return f"Error explaining concept: {str(e)}"
-
-final_answer = FinalAnswerTool()
-
-# Initialize the model
-model = HfApiModel(
-    max_tokens=2096,
-    temperature=0.5,
-    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-)
-
-# Load additional tools
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
-
-# Create the enhanced research agent
-agent = CodeAgent(
-    model=model,
-    tools=[
-        final_answer,
-        initialize_perplexity,
-        get_ai_research_papers,
-        summarize_paper,
-        get_citation,
-        explain_concept,
-        image_generation_tool,
-    ],
-    max_steps=6,
-    verbosity_level=1,
-    grammar=None,
-    planning_interval=None,
-    name="AI Research Assistant",
-    description="An AI-powered research assistant for exploring AI-related papers and concepts using Perplexity API.",
-    prompt_templates=prompt_templates
-)
-
 # Function to handle chat UI interactions
 def chat_ui_interaction(query: str, chat_history: list):
     """Handles user queries in the chat UI, showing the agent's thought process."""
+    global perplexity_api_key, perplexity_model
     # Add user message to chat history
     chat_history.append(("user", query))
     
@@ -221,16 +27,16 @@ def chat_ui_interaction(query: str, chat_history: list):
         # Example: Decide which tool to use based on the query
         if "explain" in query.lower():
             thought_process.append("🔍 Using the 'explain_concept' tool...")
-            result = explain_concept(query)
+            result = explain_concept(query, perplexity_api_key, perplexity_model)
         elif "summarize" in query.lower():
             thought_process.append("📄 Using the 'summarize_paper' tool...")
-            result = summarize_paper(query)
+            result = summarize_paper(query, perplexity_api_key, perplexity_model)
         elif "citation" in query.lower():
             thought_process.append("📚 Using the 'get_citation' tool...")
-            result = get_citation(query)
+            result = get_citation(query, perplexity_api_key, perplexity_model)
         else:
             thought_process.append("🔎 Using the 'get_ai_research_papers' tool...")
-            result = get_ai_research_papers(query)
+            result = get_ai_research_papers(query, perplexity_api_key, perplexity_model)
         
         # Add thought process to chat history
         for step in thought_process:
@@ -289,7 +95,7 @@ def create_ui():
             search_results = gr.Textbox(label="Search Results")
             search_button.click(
                 fn=get_ai_research_papers,
-                inputs=input_query,
+                inputs=[input_query, input_api_key, model_dropdown],
                 outputs=search_results
             )
             
@@ -300,7 +106,7 @@ def create_ui():
             paper_summary = gr.Textbox(label="Paper Summary")
             summarize_button.click(
                 fn=summarize_paper,
-                inputs=input_paper_title,
+                inputs=[input_paper_title, input_api_key, model_dropdown],
                 outputs=paper_summary
             )
             
@@ -311,7 +117,7 @@ def create_ui():
             citation_output = gr.Textbox(label="Citation")
             citation_button.click(
                 fn=get_citation,
-                inputs=input_citation_title,
+                inputs=[input_citation_title, input_api_key, model_dropdown],
                 outputs=citation_output
             )
             
@@ -322,7 +128,7 @@ def create_ui():
             explanation_output = gr.Textbox(label="Explanation")
             explain_button.click(
                 fn=explain_concept,
-                inputs=input_concept,
+                inputs=[input_concept, input_api_key, model_dropdown],
                 outputs=explanation_output
             )