Change instructions

.gitignore

@@ -5,3 +5,4 @@ uv.lock
 .gradio
 __pycache__/
 *.pyc
+.vscode

agents/analysis_agent.py

@@ -10,7 +10,8 @@ from loguru import logger
 
 from config import load_prompt_templates
 from tools.search_tools import ThrottledDuckDuckGoSearchTool
-from tools.analysis_tools import analyze_lyrics_tool
+from tools.analysis_tools import AnalyzeLyricsTool
+from tools.formatting_tools import FormatAnalysisResultsTool
 
 
 def create_analysis_agent(model):
@@ -42,7 +43,7 @@ def create_analysis_agent(model):
     
     agent = CodeAgent(
         model=model,
-        tools=[throttled_search_tool, VisitWebpageTool(), analyze_lyrics_tool],
+        tools=[throttled_search_tool, VisitWebpageTool(), AnalyzeLyricsTool(), FormatAnalysisResultsTool()],
         name="lyrics_analysis_agent",
         description="Specialized agent for analyzing song lyrics and providing detailed commentary",
         additional_authorized_imports=["numpy", "bs4", "json", "re"],

agents/single_agent.py

@@ -3,10 +3,12 @@ Web agent for finding and extracting song lyrics from online sources.
 """
 
 from loguru import logger
-from smolagents import CodeAgent, VisitWebpageTool, FinalAnswerTool
+from smolagents import CodeAgent, VisitWebpageTool, FinalAnswerTool, DuckDuckGoSearchTool
 
-from tools.analysis_tools import analyze_lyrics_tool
-from tool.search_tools import ThrottledDuckDuckGoSearchTool
+from config import load_prompt_templates
+from tools.search_tools import ThrottledDuckDuckGoSearchTool
+from tools.analysis_tools import AnalyzeLyricsTool
+from tools.formatting_tools import FormatAnalysisResultsTool
 
 
 def create_single_agent(model):
@@ -19,21 +21,24 @@ def create_single_agent(model):
     Returns:
         A configured CodeAgent for web searches
     """
-    
+    prompt_templates = load_prompt_templates()
+
     # Define agent parameters directly in the code instead of using config
     # Example usage within the agent
     agent = CodeAgent(
         tools=[
             FinalAnswerTool(),
-            ThrottledDuckDuckGoSearchTool(),
+            DuckDuckGoSearchTool(),
             VisitWebpageTool(),
-            analyze_lyrics_tool
+            AnalyzeLyricsTool(),
+            FormatAnalysisResultsTool()
         ],
         model=model,
         additional_authorized_imports=['numpy', 'bs4', 'rich'],
         max_steps=25,
         verbosity_level=2,
-        description="Specialized agent for finding and extracting song, specified by the user. Does not use genius.com and AZlyrics.com for scraping since they have protection. Performs lyrics search and analysys using given tools. Provides detailed commentary using FinalAnswerTool meaning with beautiful human-readable format.",
+        description="Specialized agent for finding and extracting song lyrics specified by the user. Does not use genius.com and AZlyrics.com for scraping since they have protection mechanisms. Performs lyrics search and analysis using given tools. Provides detailed commentary with beautiful human-readable format using rich library formatting. Can format analysis results in either rich colorful output or simple text format.",
+        prompt_templates=prompt_templates
     )
     
     logger.info("Web agent (lyrics search) created successfully")

app.py

@@ -29,7 +29,15 @@ def main():
     # Initialize the LLM model based on configuration
     model_id = get_model_id()
     logger.info(f"Initializing with model: {model_id}")
-    model = LiteLLMModel(model_id=model_id)
+    
+    # If using Ollama, we need to specify the API base URL
+    if "ollama" in model_id:
+        from config import get_ollama_api_base
+        api_base = get_ollama_api_base()
+        logger.info(f"Using Ollama API base: {api_base}")
+        model = LiteLLMModel(model_id=model_id, api_base=api_base)
+    else:
+        model = LiteLLMModel(model_id=model_id)
     
     # Create the manager agent which will create and manage the other agents
     single_agent = create_single_agent(model)

config.py

@@ -24,28 +24,24 @@ def load_api_keys():
     """Load API keys from environment variables."""
     # Gemini API is the default
     os.environ["GEMINI_API_KEY"] = os.getenv("GEMINI_API_KEY")
-    
-    # Anthropic API for local testing
-    if use_anthropic():
-        os.environ["ANTHROPIC_API_KEY"] = os.getenv("ANTHROPIC_API_KEY")
-
-# Default model configuration
-def use_anthropic():
-    """Check if we should use Anthropic instead of Gemini."""
-    return os.getenv("USE_ANTHROPIC", "false").lower() == "true"
+    os.environ["ANTHROPIC_API_KEY"] = os.getenv("ANTHROPIC_API_KEY")
 
-def get_model_id():
+def get_model_id(is_test=True):
     """Get the appropriate model ID based on configuration."""
-    if use_anthropic():
-        return "claude-3-haiku-20240307"
+    if is_test:
+        return "ollama/gemma3:4b"  # Using local Ollama with Gemma 3:4B instead of Claude
     else:
         return "gemini/gemini-2.0-flash"
 
+def get_ollama_api_base():
+    """Get the API base URL for Ollama."""
+    return "http://localhost:11434"
+
 # Load prompts from YAML
 def load_prompt_templates():
     """Load prompt templates from YAML file."""
     try:
-        with open("prompts_hf.yaml", 'r') as stream:
+        with open("prompts/prompts_hf.yaml", 'r') as stream:
             return yaml.safe_load(stream)
     except (FileNotFoundError, yaml.YAMLError) as e:
         logger.error(f"Error loading prompts.yaml: {e}")

tools/analysis_tools.py

@@ -4,78 +4,96 @@ Analysis tools for understanding and interpreting song lyrics.
 
 import os
 from loguru import logger
-from smolagents import tool
+from smolagents import Tool
 
 from api_utils import make_api_call_with_retry
+from tools.formatting_tools import FormatAnalysisResultsTool
 
-@tool
-def analyze_lyrics_tool(song_title: str, artist: str, lyrics: str) -> str:
-    """
-    Performs a deep analysis of the musical track, given its metadata.
 
-    Args:
-        song_title: Title of the song or music track.
-        artist: The name of the artist.
-        lyrics: The lyrics of the song.
-
-    Returns:
-        A summary of the song's meaning in English.
-    """
-
-    prompt = f"""You are an expert in songs and their meanings.
-    
-    Analyze the song "{song_title}" by {artist}. Return a structured JSON with the following information:
-    
-    1. Overall analysis of the song including themes, mood, meaning, and context.
-    2. Section-by-section analysis of each part of the song (verses, chorus, bridge, etc.).
-    3. Line-specific insights for particularly significant lines.
-    4. A conclusion about what makes this song unique or significant.
-    
-    Format your response as a valid JSON object with the following structure:
-    ```
-    {{
-        "summary": "Overall analysis of the song themes, meaning and mood",
-        "main_themes": ["theme1", "theme2", ...],
-        "mood": "The overall mood/emotion of the song",
-        "sections_analysis": [
-            {{
-                "section_type": "verse/chorus/bridge/etc.",
-                "section_number": 1,
-                "lines": ["line1", "line2", ...],
-                "analysis": "Analysis of this section"
-            }},
-            ...
-        ],
-        "significant_lines": [
-            {{
-                "line": "A specific important line",
-                "significance": "Why this line is important"
-            }},
-            ...
-        ],
-        "conclusion": "What makes this song significant or unique"
-    }}
-    ```
+class AnalyzeLyricsTool(Tool):
+    """Tool for analyzing song lyrics"""
     
-    Make sure your response is a properly formatted JSON. Only provide the JSON object, no other text.
+    name = "analyze_lyrics"
+    description = "Analyzes song lyrics and returns a detailed analysis"
+    inputs = {
+        "song_title": {"type": "string", "description": "Title of the song"},
+        "artist": {"type": "string", "description": "Name of the artist"},
+        "lyrics": {"type": "string", "description": "Lyrics of the song"},
+        "format_output": {"type": "boolean", "description": "Whether to format the output with rich styling", "nullable": True}
+    }
+    output_type = "string"
     
-    Here are the lyrics to analyze:
-    {lyrics}
-    """
+    def forward(self, song_title: str, artist: str, lyrics: str, format_output: bool = True) -> str:
+        """
+        Performs a deep analysis of the musical track, given its metadata.
 
-    # Determine which model to use based on configuration
-    if os.getenv("USE_ANTHROPIC", "false").lower() == "true":
-        model_to_use = "claude-3-haiku-20240307"
-        logger.info("Using Anthropic model: {} for lyrics analysis", model_to_use)
-    else:
-        model_to_use = "gemini/gemini-2.0-flash"
-        logger.info("Using Gemini model: {} for lyrics analysis", model_to_use)
+        Args:
+            song_title: Title of the song or music track.
+            artist: The name of the artist.
+            lyrics: The lyrics of the song.
+            format_output: Whether to format the output using rich formatting (default: True).
 
-    # Use the function with retry mechanism
-    logger.info("Analyzing lyrics for song: '{}' by '{}'", song_title, artist)
-    # Get raw analysis as JSON
-    response = make_api_call_with_retry(model_to_use, prompt)
-    
-    # Note: we're returning the raw response which should be a JSON string
-    # The agent will be responsible for parsing and formatting this data
-    return response
+        Returns:
+            A formatted analysis of the song's meaning in English or raw JSON if format_output is False.
+        """
+
+        prompt = f"""You are an expert in songs and their meanings.
+        
+        Analyze the song "{song_title}" by {artist}. Return a structured JSON with the following information:
+        
+        1. Overall analysis of the song including themes, mood, meaning, and context.
+        2. Section-by-section analysis of each part of the song (verses, chorus, bridge, etc.).
+        3. Line-specific insights for particularly significant lines.
+        4. A conclusion about what makes this song unique or significant.
+        
+        Format your response as a valid JSON object with the following structure:
+        ```
+        {{
+            "summary": "Overall analysis of the song themes, meaning and mood",
+            "main_themes": ["theme1", "theme2", ...],
+            "mood": "The overall mood/emotion of the song",
+            "sections_analysis": [
+                {{
+                    "section_type": "verse/chorus/bridge/etc.",
+                    "section_number": 1,
+                    "lines": ["line1", "line2", ...],
+                    "analysis": "Analysis of this section"
+                }},
+                ...
+            ],
+            "significant_lines": [
+                {{
+                    "line": "A specific important line",
+                    "significance": "Why this line is important"
+                }},
+                ...
+            ],
+            "conclusion": "What makes this song significant or unique"
+        }}
+        ```
+        
+        Make sure your response is a properly formatted JSON. Only provide the JSON object, no other text.
+        
+        Here are the lyrics to analyze:
+        {lyrics}
+        """
+
+        # Determine which model to use based on configuration
+        if os.getenv("USE_ANTHROPIC", "false").lower() == "true":
+            model_to_use = "claude-3-haiku-20240307"
+            logger.info("Using Anthropic model: {} for lyrics analysis", model_to_use)
+        else:
+            model_to_use = "gemini/gemini-2.0-flash"
+            logger.info("Using Gemini model: {} for lyrics analysis", model_to_use)
+
+        # Use the function with retry mechanism
+        logger.info("Analyzing lyrics for song: '{}' by '{}'", song_title, artist)
+        # Get raw analysis as JSON
+        response = make_api_call_with_retry(model_to_use, prompt)
+
+        # Format the response if requested
+        if format_output:
+            formatter = FormatAnalysisResultsTool()
+            return formatter.forward(response)
+        else:
+            return response

tools/formatting_tools.py

@@ -0,0 +1,230 @@
+"""
+Formatting tools for displaying analysis results with rich formatting.
+"""
+
+import json
+from loguru import logger
+from smolagents import Tool
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+from rich.markdown import Markdown
+from rich.theme import Theme
+from rich.box import ROUNDED
+from rich.console import Group
+
+
+class FormatAnalysisResultsTool(Tool):
+    """Tool for formatting analysis results"""
+    
+    name = "format_analysis_results"
+    description = "Formats the analysis results for better readability"
+    inputs = {
+        "analysis_json": {"type": "any", "description": "JSON string or dictionary containing the analysis results"},
+        "pretty": {"type": "boolean", "description": "Whether to use rich formatting (True) or simple text formatting (False)", "nullable": True}
+    }
+    output_type = "string"
+    
+    def forward(self, analysis_json, pretty: bool = True) -> str:
+        """
+        Formats the analysis results for better readability.
+        
+        Args:
+            analysis_json: JSON string or dictionary containing the analysis results
+            pretty: Whether to use rich formatting (True) or simple text formatting (False)
+            
+        Returns:
+            A formatted string representation of the analysis
+        """
+        try:
+            # Parse the JSON string into a Python dictionary if it's a string
+            if isinstance(analysis_json, str):
+                analysis = json.loads(analysis_json)
+            else:
+                analysis = analysis_json
+                
+            if pretty:
+                # Rich formatting with the rich library
+                try:
+                    # Create a string buffer to capture the rich output
+                    console = Console(record=True, width=100)
+                    
+                    # Create a custom theme for consistent styling
+                    custom_theme = Theme({
+                        "heading": "bold cyan underline",
+                        "subheading": "bold blue",
+                        "highlight": "bold yellow",
+                        "positive": "green",
+                        "negative": "red",
+                        "neutral": "magenta",
+                        "section": "cyan",
+                        "quote": "italic yellow",
+                        "metadata": "dim white"
+                    })
+                    
+                    # Apply the theme to our console
+                    console.theme = custom_theme
+                    
+                    # Format the summary section
+                    summary = analysis.get("summary", "No summary available")
+                    console.print(Panel(Text(summary, justify="center"), title="[heading]Song Analysis[/]", subtitle="[metadata]Summary[/]"))
+                    
+                    # Create a table for the main themes and mood
+                    info_table = Table(show_header=False, box=ROUNDED, expand=True)
+                    info_table.add_column("Key", style="subheading")
+                    info_table.add_column("Value")
+                    
+                    # Add the mood
+                    mood = analysis.get("mood", "Not specified")
+                    info_table.add_row("Mood", mood)
+                    
+                    # Add the themes as a comma-separated list
+                    themes = analysis.get("main_themes", [])
+                    if themes:
+                        themes_text = ", ".join([f"[highlight]{theme}[/]" for theme in themes])
+                        info_table.add_row("Main Themes", themes_text)
+                    
+                    console.print(info_table)
+                    
+                    # Section-by-section analysis
+                    sections = analysis.get("sections_analysis", [])
+                    if sections:
+                        console.print("\n[heading]Section-by-Section Analysis[/]")
+                        
+                        for section in sections:
+                            section_type = section.get("section_type", "Unknown")
+                            section_number = section.get("section_number", "")
+                            section_title = f"{section_type.title()} {section_number}" if section_number else section_type.title()
+                            
+                            section_analysis = section.get("analysis", "No analysis available")
+                            lines = section.get("lines", [])
+                            
+                            # Create a group with the lyrics and analysis
+                            section_content = []
+                            
+                            if lines:
+                                lyrics_text = "\n".join([f"> [quote]{line}[/]" for line in lines])
+                                section_content.append(Text("Lyrics:", style="subheading"))
+                                section_content.append(Markdown(lyrics_text))
+                            
+                            section_content.append(Text("Analysis:", style="subheading"))
+                            section_content.append(Text(section_analysis))
+                            
+                            # Add the section panel
+                            console.print(Panel(
+                                Group(*section_content),
+                                title=f"[section]{section_title}[/]",
+                                border_style="section"
+                            ))
+                    
+                    # Significant lines
+                    sig_lines = analysis.get("significant_lines", [])
+                    if sig_lines:
+                        console.print("\n[heading]Significant Lines[/]")
+                        
+                        for i, line_data in enumerate(sig_lines):
+                            line = line_data.get("line", "")
+                            significance = line_data.get("significance", "")
+                            
+                            console.print(Panel(
+                                f"[quote]\"{line}\"[/]\n\n[subheading]Significance:[/] {significance}",
+                                title=f"[highlight]Key Line #{i+1}[/]",
+                                border_style="highlight"
+                            ))
+                    
+                    # Conclusion
+                    conclusion = analysis.get("conclusion", "No conclusion available")
+                    console.print("\n[heading]Conclusion[/]")
+                    console.print(Panel(conclusion, border_style="neutral"))
+                    
+                    # Export the rich text as a string
+                    return console.export_text()
+                    
+                except Exception as e:
+                    logger.error("Error in rich formatting: {}", str(e))
+                    # Fall back to simple formatting if rich formatting fails
+                    logger.info("Falling back to simple text formatting")
+                    pretty = False
+            
+            if not pretty:
+                # Simple text formatting
+                formatted_text = []
+                
+                # Summary
+                formatted_text.append("SONG ANALYSIS SUMMARY")
+                formatted_text.append("====================")
+                formatted_text.append(analysis.get("summary", "No summary available"))
+                formatted_text.append("")
+                
+                # Main themes
+                themes = analysis.get("main_themes", [])
+                if themes:
+                    formatted_text.append("MAIN THEMES")
+                    formatted_text.append("===========")
+                    for theme in themes:
+                        formatted_text.append(f"• {theme}")
+                    formatted_text.append("")
+                
+                # Mood
+                mood = analysis.get("mood", "Not specified")
+                formatted_text.append("MOOD")
+                formatted_text.append("====")
+                formatted_text.append(mood)
+                formatted_text.append("")
+                
+                # Sections analysis
+                sections = analysis.get("sections_analysis", [])
+                if sections:
+                    formatted_text.append("SECTION-BY-SECTION ANALYSIS")
+                    formatted_text.append("==========================")
+                    
+                    for i, section in enumerate(sections):
+                        section_type = section.get("section_type", "Unknown")
+                        section_number = section.get("section_number", i+1)
+                        section_analysis = section.get("analysis", "No analysis available")
+                        
+                        formatted_text.append(f"{section_type.upper()} {section_number}")
+                        formatted_text.append("-" * (len(section_type) + len(str(section_number)) + 1))
+                        
+                        # Format the section lines
+                        lines = section.get("lines", [])
+                        if lines:
+                            formatted_text.append("Lyrics:")
+                            for line in lines:
+                                formatted_text.append(f"> {line}")
+                            formatted_text.append("")
+                        
+                        formatted_text.append("Analysis:")
+                        formatted_text.append(section_analysis)
+                        formatted_text.append("")
+                
+                # Significant lines
+                sig_lines = analysis.get("significant_lines", [])
+                if sig_lines:
+                    formatted_text.append("SIGNIFICANT LINES")
+                    formatted_text.append("=================")
+                    
+                    for i, line_data in enumerate(sig_lines):
+                        line = line_data.get("line", "")
+                        significance = line_data.get("significance", "")
+                        
+                        formatted_text.append(f"Key Line #{i+1}:")
+                        formatted_text.append(f'"{line}"')
+                        formatted_text.append(f"Significance: {significance}")
+                        formatted_text.append("")
+                
+                # Conclusion
+                conclusion = analysis.get("conclusion", "No conclusion available")
+                formatted_text.append("CONCLUSION")
+                formatted_text.append("==========")
+                formatted_text.append(conclusion)
+                
+                return "\n".join(formatted_text)
+                
+        except json.JSONDecodeError:
+            logger.error("Failed to parse analysis JSON: {}", analysis_json[:100] + "..." if len(analysis_json) > 100 else analysis_json)
+            return f"Error: Could not parse the analysis result as JSON. Raw output:\n{analysis_json}"
+        except Exception as e:
+            logger.error("Error formatting analysis: {}", str(e))
+            return f"Error formatting analysis: {str(e)}\nRaw output:\n{analysis_json}"

tools/search_tools.py

@@ -8,6 +8,7 @@ from typing import Dict, List, Any
 from loguru import logger
 from smolagents import DuckDuckGoSearchTool
 
+
 class ThrottledDuckDuckGoSearchTool(DuckDuckGoSearchTool):
     """
     A wrapper around DuckDuckGoSearchTool that adds a delay between requests
@@ -17,12 +18,12 @@ class ThrottledDuckDuckGoSearchTool(DuckDuckGoSearchTool):
     Each search request will be followed by a random delay within the specified range.
     """
     
-    def __init__(self, min_delay: float = 5.0, max_delay: float = 12.0, **kwargs):
+    def __init__(self, min_delay: float = 7.0, max_delay: float = 15.0, **kwargs):
         """
         Initialize the throttled search tool with delay parameters.
         
         Args:
-            min_delay: Minimum delay in seconds between requests (default: 2.0)
+            min_delay: Minimum delay in seconds between requests (default: 5.0)
             max_delay: Maximum delay in seconds between requests (default: 5.0)
             **kwargs: Additional arguments to pass to DuckDuckGoSearchTool
         """