Mastering YouTube Content Analysis with AI Agents

Why Video Analysis Matters

In today’s video-dominated content landscape, professionals need tools to quickly:

• Extract key information from long videos
• Create structured learning guides
• Analyze technical content efficiently
• Compare product features systematically

With 500 hours of video uploaded to YouTube every minute, professionals face:

• Information overload in tutorials and reviews
• Missed insights in hour-long webinars
• Inconsistent manual analysis methods

Enter AI-powered YouTube Agents – your 24/7 digital analyst combining:

Azure OpenAI (GPT-4o) + Agno Framework + YouTube API = 🚀 Supercharged Analysis

Our solution combines:

• 🧠 Azure OpenAI’s GPT-4o for cognitive tasks
• 🔧 Customizable agents for domain-specific analysis
• 🎥 YouTube Tools for direct video processing

Implementation Deep Dive

1. Prerequisites

# Install required packages
pip install streamlit agno-library python-dotenv youtube-transcript-api

Environment Setup

Create .env file:

AZURE_OPENAI_API_KEY=your_azure_key
AZURE_OPENAI_ENDPOINT=your_azure_endpoint

 Code Structure

import streamlit as st
from textwrap import dedent
from agno.agent import Agent
from agno.tools.youtube import YouTubeTools
from agno.models.azure import AzureOpenAI
from dotenv import load_dotenv

load_dotenv()

# Initialize Streamlit
st.set_page_config(
    page_title="Learn Video Analysis With help of Agno Agents",
    page_icon="🔥",
    layout="wide"
)

def initialize_agent():
    """Configure AI agent with YouTube analysis capabilities"""
    return Agent(
        name="YouTube Agent",
        model=AzureOpenAI(id="gpt-4o"),
        tools=[YouTubeTools()],
        show_tool_calls=True,
        instructions=dedent("""\
            <instructions>
            // Detailed instructions from original code
            </instructions>
        """),
        add_datetime_to_instructions=True,
        markdown=True,
    )

# [Include remaining functions from original code]

Launch the Application

streamlit run video_analysis.py

Usage Workflow

1. Select analysis type from sidebar
2. Paste YouTube URL in main input
3. Choose between default or custom prompt
4. Click “Analyze Video”
5. View structured analysis in expandable section

"""
YouTube Video Analysis Agent with Azure OpenAI and Agno Framework
Streamlit web application for structured video content analysis
"""

# ----- [1] IMPORT DEPENDENCIES -----
# Standard library imports
import os
from textwrap import dedent

# Third-party imports
import streamlit as st
from dotenv import load_dotenv

# Agno framework components
from agno.agent import Agent
from agno.tools.youtube import YouTubeTools
from agno.models.azure import AzureOpenAI

# ----- [2] ENVIRONMENT SETUP -----
# Load environment variables from .env file
load_dotenv()  # Required for Azure credentials (AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT)

# ----- [3] STREAMLIT PAGE CONFIGURATION -----
st.set_page_config(
    page_title="Learn Video Analysis With help of Agno Agents",
    page_icon="🔥",
    layout="wide"
)

# ----- [4] AGENT CONFIGURATION -----
def initialize_youtube_agent() -> Agent:
    """
    Create and configure the YouTube analysis agent with specialized capabilities
    
    Returns:
        Agent: Configured Agno agent instance with YouTube analysis tools
    """
    return Agent(
        name="YouTube Agent",
        model=AzureOpenAI(id="gpt-4o"),  # Azure OpenAI model configuration
        tools=[YouTubeTools()],  # YouTube-specific analysis tools
        show_tool_calls=True,  # Display tool execution details
        instructions=dedent(f"""\
            <instructions>
            You are an expert YouTube content analyst with a keen eye for detail! 🎓
            
            <!-- Analysis Process Structure -->
            <analysis_steps>
            1. Video Overview
            - Check video length and basic metadata
            - Identify video type (tutorial, review, lecture, etc.)
            - Note the content structure
            
            2. Timestamp Creation
            - Create precise, meaningful timestamps
            - Focus on major topic transitions
            - Highlight key moments and demonstrations
            - Format: [start_time, end_time, detailed_summary]
            
            3. Content Organization
            - Group related segments
            - Identify main themes
            - Track topic progression
            </analysis_steps>
            
            <!-- Styling and Formatting Guidelines -->
            <style_guidelines>
            - Begin with video overview
            - Use clear, descriptive segment titles
            - Include relevant emojis:
              📚 Educational | 💻 Technical | 🎮 Gaming 
              📱 Tech Review | 🎨 Creative
            - Highlight key learning points
            - Note practical demonstrations
            - Mark important references
            </style_guidelines>
            
            <!-- Quality Assurance Measures -->
            <quality_control>
            - Verify timestamp accuracy
            - Avoid timestamp hallucination
            - Ensure comprehensive coverage
            - Maintain consistent detail level
            - Focus on valuable content markers
            </quality_control>
            </instructions>
        """),
        add_datetime_to_instructions=True,  # Add temporal context to analysis
        markdown=True,  # Enable Markdown formatting in output
    )

# ----- [5] SIDEBAR COMPONENTS -----
def create_analysis_sidebar() -> tuple:
    """
    Build the collapsible sidebar with analysis templates
    
    Returns:
        tuple: (selected analysis type, default prompt)
    """
    with st.sidebar:
        st.markdown("### Quick Analysis Templates 🎯")
        
        # Analysis template configurations
        ANALYSIS_TEMPLATES = {
            "Tutorial Analysis": {
                "emoji": "💻",
                "description": "Code examples & steps",
                "prompt": "Analyze code examples and implementation steps, Identify key concepts and implementation examples"
            },
            "Educational Content": {
                "emoji": "📚",
                "description": "Learning material",
                "prompt": "Create study guide with key concepts,Summarize the main arguments in this academic presentation"
            },
            "Tech Reviews": {
                "emoji": "📱",
                "description": "Product analysis",
                "prompt": "Extract features and comparisons,List all product features mentioned with timestamps"
            },
            "Creative Content": {
                "emoji": "🎨",
                "description": "Art & design",
                "prompt": "Document techniques and methods,List all tools and materials mentioned with timestamps"
            }
        }
        
        # Template selection widget
        selected_type = st.selectbox(
            "Select Analysis Type",
            options=list(ANALYSIS_TEMPLATES.keys()),
            format_func=lambda x: f"{ANALYSIS_TEMPLATES[x]['emoji']} {x}"
        )
        
        # Template details expander
        with st.expander("Analysis Details", expanded=False):
            st.markdown(f"**{ANALYSIS_TEMPLATES[selected_type]['description']}**")
            st.markdown(f"Default prompt: _{ANALYSIS_TEMPLATES[selected_type]['prompt']}_")
        
        return selected_type, ANALYSIS_TEMPLATES[selected_type]['prompt']

# ----- [6] MAIN CONTENT AREA -----
def display_main_content(analysis_type: str, default_prompt: str) -> None:
    """
    Handle core application functionality and UI
    
    Args:
        analysis_type (str): Selected analysis template
        default_prompt (str): Preconfigured prompt for selected template
    """
    st.title("Learn Video Analysis With help of Agno Agents & AZURE OPEN AI 📹🔍")
    
    # Create input columns layout
    input_col, config_col = st.columns([2, 1])
    
    with input_col:
        video_url = st.text_input(
            "Enter YouTube URL:",
            placeholder="https://youtube.com/...",
            help="Paste a valid YouTube video URL for analysis"
        )
    
    with config_col:
        # Custom prompt toggle
        custom_prompt = st.checkbox(
            "Customize Analysis Prompt",
            help="Override default analysis instructions"
        )
    
    # Dynamic prompt configuration
    analysis_prompt = (
        st.text_area(
            "Analysis Instructions:",
            value=default_prompt,
            height=100
        ) if custom_prompt else default_prompt
    )
    
    # Analysis execution flow
    if st.button("Analyze Video 🔍", type="primary"):
        if not video_url:
            st.warning("⚠️ Please enter a YouTube URL")
            return
        
        try:
            youtube_agent = initialize_youtube_agent()
            with st.spinner("📊 Processing video content..."):
                # Execute agent analysis pipeline
                result = youtube_agent.run(
                    f"URL: {video_url}\nInstructions: {analysis_prompt}"
                )
                st.success("✅ Analysis Complete!")
                
                # Display results in expandable section
                with st.expander("View Analysis", expanded=True):
                    st.markdown(result.content)
        
        except Exception as error:
            st.error("⚠️ Analysis failed. Please check your URL and try again.")
            with st.expander("Technical Details"):
                st.code(str(error))  # Debugging information

# ----- [7] APPLICATION ENTRY POINT -----
def main():
    """Main application workflow controller"""
    analysis_type, default_prompt = create_analysis_sidebar()
    display_main_content(analysis_type, default_prompt)

if __name__ == "__main__":
    main()

Performance Metrics

Troubleshooting Guide

Future Enhancements

1. Multi-video comparison reports
2. Automated summary PDF generation
3. Custom template support

Conclusion
This implementation demonstrates how AI agents can transform raw video content into structured, actionable knowledge. By combining Streamlit’s UI capabilities with Agno’s flexible agent framework, we’ve created a powerful tool for content analysis that adapts to various professional needs.

[Download Full Code on GitHub] |

Read More – https://github.com/agno-agi/agno/blob/main/cookbook/examples/agents/youtube_agent.py