initial commit

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY=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

app.py

@@ -0,0 +1,1077 @@
+#try using existing logic, but add ctx/memory that llamindex allows
+
+#do autonomous llamagents
+
+from llama_index.core.tools import FunctionTool
+from llama_index.llms.openai import OpenAI as LlamaOpenAI
+from dotenv import load_dotenv
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.llms.google_genai import GoogleGenAI
+from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent, ReActAgent #can also import ReActAgent or FunctionAgent from this 
+from llama_index.core.tools import FunctionTool
+from llama_index.core.workflow import Context
+import os
+from functools import lru_cache
+import asyncio
+import requests
+from llama_index.core.agent.workflow import (
+    AgentInput,
+    AgentOutput,
+    ToolCall,
+    ToolCallResult,
+    AgentStream,
+)
+import openai
+import tiktoken
+import requests
+import json
+import gradio as gr
+from openai import OpenAI 
+from testDynamic import generate_questions_dynamic
+
+
+#from llama_index.llms.google_gemini import GoogleGenAI
+#from google.genai import types
+
+load_dotenv()
+
+#llm = OpenAI(model="gpt-4o-mini")
+import google.generativeai as genai
+
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+llmGeminiPro = GoogleGenAI(model="gemini-2.5-pro")
+print("llmGeminiPro loaded!")
+
+llmGeminiFlash = GoogleGenAI(model="gemini-2.5-flash")
+print("llmGeminiFlash loaded!")
+
+llm = LlamaOpenAI(
+    model="gpt-4o-mini",  # or "gpt-3.5-turbo"
+    api_key=os.getenv('OPENAI_API_KEY'),  # You can also set this via the OPENAI_API_KEY environment variable
+    streaming=True    
+)
+
+llmHigher = LlamaOpenAI(
+    model="o3",
+    api_key=os.getenv('OPENAI_API_KEY'),
+    streaming=True
+)
+
+client = OpenAI(
+    api_key=os.getenv('OPENAI_API_KEY'),
+)
+
+openai.api_key = os.getenv("OPENAI_API_KEY")
+#use gemini
+
+#set api_key in .env for gemini
+#llmGemini = GoogleGenAI(model="gemini-2.5-pro")
+
+#can use search as AI
+#google_search_tool = types.Tool(
+    #google_search=types.GoogleSearch()
+#)#should be able to pass as tool?
+
+
+
+@lru_cache(maxsize=1)
+def get_chartmetric_access_token_cached() -> str | None:
+    print("🔑 Fetching new Chartmetric token")
+    return get_chartmetric_access_token_with_refresh()
+
+#@function_tool
+def get_chartmetric_access_token_with_refresh() -> str or None:
+    """
+    Retrieves an access token from Chartmetric. You need to use this before you can use any other function involving chartmetric
+    
+    """
+    #current_state = await ctx.get('state')
+
+
+    refresh_token = 'izPNc1uMM7A13dvWGs0Gij3rfMTKV0K24ADFfcHviaOPWxc35ZsNuYqlQNb5BVyG'
+
+    endpoint = 'https://api.chartmetric.com/api/token'
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    payload = {
+        'refreshtoken': refresh_token
+    }
+
+    try:
+        response = requests.post(endpoint, headers=headers, json=payload)
+        if not response.ok:
+            raise Exception(f"Token request failed: {response.status_code} {response.reason}")
+        
+        data = response.json()
+        print("Access token retrieved:", data.get('token'),{})
+
+       #if "working_notes" not in current_state:
+            #current_state["working_notes"] = {}
+        
+        access_token = data.get('token')# This is your bearer token for future API calls
+        #current_state["working_notes"]["access_token"] = access_token
+
+        #await ctx.set("state", current_state)
+        return access_token
+
+    except Exception as e:
+        print("Error retrieving Chartmetric access token:", str(e))
+        return None
+
+
+
+#@function_tool
+async def find_artist_id_for_artist(ctx: Context, artist_name: str) -> int:
+    """
+    Retrieves artist_id for the artist you want to search on the chartmetric system .
+
+    
+    """
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of find_artist_id_for_artist is: {current_state}")
+ 
+    access_token = get_chartmetric_access_token_cached()
+
+    url = f'https://api.chartmetric.com/api/search?q={artist_name}&type=artists'
+
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+    
+    try: 
+        response = requests.get(url, headers=headers)
+        
+        if not response.ok:
+            raise Exception(f"artist_id request failed: {response.status_code} {response.reason}")
+
+        data = response.json()
+        print("Raw response data:", data)
+        
+        # Safely access first matched artist
+        artists = data.get("obj", {}).get("artists", [])
+        
+        if not artists:
+            print(f"No artists found matching '{artist_name}'.")
+            return None
+        
+        artist_id = artists[0].get('id',{})
+
+        # Update state and persist it
+        if "working_notes" not in current_state:
+            current_state["working_notes"] = {}
+
+        current_state["working_notes"][f"artist_id_for_{artist_name}"] = artist_id
+        await ctx.store.set("state", current_state)  # 🟢 Save the updated state
+        print(f"🧠 Updated working_notes in find_artist_id_for_artist: {json.dumps(current_state['working_notes'], indent=2)}")
+
+
+        return artist_id
+
+    except Exception as e:
+        print("Error retrieving Chartmetric artist_id:", str(e))
+        return None
+
+#@function_tool
+async def get_similar_artists(ctx: Context, artist_id: int) -> dict:
+    """
+    Retrieve a list of similar artists from Chartmetric based on a given artist ID.
+
+    Parameters:
+    - artist_id (int): The Chartmetric artist ID.
+
+    Returns:
+    - dict: A dictionary of similar artists (up to 5).
+
+    Notes:
+    - Results are stored in working memory under "similar_artists".
+    """
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of get_similar_artists is: {current_state}")
+
+    access_token = get_chartmetric_access_token_cached()  # Assuming this is defined elsewhere
+    print("access_token for get_similar_artists api call obatined!")
+
+    url = f"https://api.chartmetric.com/api/artist/{artist_id}/relatedartists?limit=3"
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+
+    try:
+        response = requests.get(url, headers=headers)
+        if not response.ok:
+            raise Exception(f"Related artists request failed: {response.status_code} {response.reason}")
+
+        data = response.json()
+        print("data returned from get_similar_artists is:", data)
+
+        
+        similar_artists = data.get('obj', {})
+
+        if "working_notes" not in current_state:
+            current_state["working_notes"] = {}
+        
+        current_state["working_notes"]["similar_artists"] = similar_artists
+        await ctx.store.set('state', current_state)
+
+        return similar_artists
+
+    except Exception as e:
+        print("Error retrieving similar artists:", str(e))
+        return None
+
+
+async def get_youtube_audience_data(ctx: Context, artist_id: str) -> dict:
+    """
+    Retrieve Youtube audience data for a given artist, using Chartmetric API.
+
+    Parameters:
+    - artist_id (int): The Chartmetric artist ID.
+
+    Returns:
+    - dict: A dictionary of similar artists (up to 5).
+
+    Notes:
+    - Results are saved in working memory.
+    """
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of get_youtube_audience_data is: {current_state}")
+    
+    access_token = get_chartmetric_access_token_cached()
+
+
+    print("🚀 Called get_Youtube with artist_id:", artist_id)
+    print("🚀 Called get_Youtube with access_token:", access_token)
+
+
+    url = f"https://api.chartmetric.com/api/artist/{artist_id}/youtube-audience-stats"
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        if response.status_code == 404:
+            print(f"⚠️ No YouTube data found for artist {artist_id}")
+            return {}
+        
+
+    data = response.json()
+    print(f"data from get_Youtube is: {data}")
+
+    dataObj = data.get('obj',{})
+
+    print("Info from get_tiktok_audience_data is:", dataObj)
+
+    compressed_notable_followers = []
+    for follower in dataObj["notable_subscribers"]:
+        #pprint(f"follower in dataObj is: {follower}")
+
+        new_data = {}
+        
+        new_data["custom_name"] = follower.get("custom_name", {})
+        new_data["subscribers"] = follower["subscribers"] 
+        new_data["engagements"] = follower["engagements"] 
+
+        compressed_notable_followers.append(new_data)
+    
+
+    dict_to_return = {"top_countries": dataObj["top_countries"], "audience_gender_by_age": dataObj["audience_genders_per_age"], "audience_genders": dataObj["audience_genders"], "top_followers": compressed_notable_followers,
+      "subscribers": dataObj["subscribers"], "avg_likes_per_post": dataObj["avg_likes_per_post"], "avg_commments_per_post": dataObj["avg_commments_per_post"],
+      "engagement_rate": dataObj["engagement_rate"]
+    
+     }
+
+    if "working_notes" not in current_state:
+        current_state["working_notes"] = {}
+    
+    youtube_audience_stats = dict_to_return
+    print(f"youtube_audience_stats are: {youtube_audience_stats}")
+    current_state["working_notes"][f"youtube_audience_data for artist {artist_id}"] = youtube_audience_stats
+    await ctx.store.set('state', current_state)
+
+    return { f"youtube_audience_data for artist {artist_id}": youtube_audience_stats}
+
+
+
+
+
+
+
+async def get_tiktok_audience_data(ctx: Context, artist_id: str) -> dict:
+    """
+    Retrieve TikTok audience data for a given artist using Chartmetric API.
+
+    Parameters:
+    - artist_id (str): The Chartmetric artist ID.
+
+    Returns:
+    - dict: TikTok audience breakdown.
+
+    Notes:
+    - Results are saved in working memory.
+    """
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of get_tiktok_audience_data is: {current_state}")
+
+    access_token = get_chartmetric_access_token_cached()
+
+
+    print("🚀 Called get_tiktok_audience_data with artist_id:", artist_id)
+    print("🚀 Called get_tiktok_audience_data with access_token:", access_token)
+
+    url = f"https://api.chartmetric.com/api/artist/{artist_id}/tiktok-audience-stats"
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        raise Exception(f"API request failed: {response.status_code} {response.reason}")
+
+    data = response.json()
+    #print(f"data from get_tiktok_audience_data is: {data}")
+
+    dataObj = data.get('obj',{})
+
+    #print("Info from get_tiktok_audience_data is:", dataObj)
+
+    compressed_notable_followers = []
+    for follower in dataObj.get("notable_followers", []):
+        #print(f"follower in dataObj is: {follower}")
+
+        new_data = {}
+        new_data["username"] = follower["username"]
+        new_data["followers"] = follower["followers"] 
+        new_data["engagement"] = follower["engagements"] 
+
+        compressed_notable_followers.append(new_data)
+    
+
+    dict_to_return = {"top_countries": dataObj["top_countries"], "audience_gender_by_age": dataObj["audience_genders_per_age"], "audience_genders": dataObj["audience_genders"], "top_followers": compressed_notable_followers,
+      "followers": dataObj["followers"], "avg_likes_per_post": dataObj["avg_likes_per_post"], "avg_commments_per_post": dataObj["avg_commments_per_post"],
+      "engagement_rate": dataObj["engagement_rate"]
+    
+     }
+    if "working_notes" not in current_state:
+        current_state["working_notes"] = {}
+    
+    tiktok_audience_stats = dict_to_return
+    #print(f"tiktok_audience_data are: {tiktok_audience_stats}")
+    current_state["working_notes"][f"tiktok_audience_data for artist {artist_id}"] = tiktok_audience_stats
+    await ctx.store.set('state', current_state)
+
+    return { f"tiktok_audience_data for artist {artist_id}": tiktok_audience_stats}
+
+    #choose which parts to return
+
+
+
+
+
+
+#@function_tool
+async def get_instagram_audience_data(ctx: Context, artist_id: str) -> dict:
+    """
+    Retrieve Instagram audience statistics for a given artist using Chartmetric.
+
+    Parameters:
+    - artist_id (str): The Chartmetric artist ID.
+
+    Returns:
+    - dict: Instagram audience breakdown.
+
+    Notes:
+    - Results are saved in working memory.
+    """
+    #perhaps just have it get access_token inside here
+    #access_token = get_chartmetric_access_token_with_refresh()
+
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of get_instagram_audience_stats is: {current_state}")
+
+    access_token = get_chartmetric_access_token_cached()
+
+
+    print("🚀 Called get_instagram_audience_stats with artist_id:", artist_id)
+    print("🚀 Called get_instagram_audience_stats with access_token:", access_token)
+    
+    url = f"https://api.chartmetric.com/api/artist/{artist_id}/instagram-audience-stats"
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        raise Exception(f"API request failed: {response.status_code} {response.reason}")
+
+    data = response.json()
+    #print(f"data from api call is: {data}")
+    #print("Info from platform Instagram is:", data.get("obj"))
+    
+
+    if "working_notes" not in current_state:
+        current_state["working_notes"] = {}
+    
+    instagram_audience_stats = data.get('obj', {})
+    current_state["working_notes"][f"instagram_audience_data for artist {artist_id}"] = instagram_audience_stats
+    await ctx.store.set('state', current_state)
+
+    return { f"instagram_audience_data for artist {artist_id}": instagram_audience_stats}
+
+
+
+async def get_charts(ctx: Context, artist_id: int, chart_type: str) -> dict:
+    """
+    Retrieve chart data for a given artist using Chartmetric API.
+
+    Parameters:
+    - artist_id (str): The Chartmetric artist ID.
+    - chart_type: The platform chart and sub-choice. Choose one from:
+        [
+            "spotify_viral_daily", "spotify_viral_weekly", "spotify_top_daily", "spotify_top_weekly",
+            "applemusic_top", "applemusic_daily", "applemusic_albums",
+            "itunes_top", "itunes_albums",
+            "shazam", "beatport",
+            "youtube", "youtube_tracks", "youtube_videos", "youtube_trends",
+            "amazon"
+        ]
+
+    Returns:
+    - dict: Chart entries containing album name, rank, and peak info.
+
+    Notes:
+    - Results are saved in working memory.
+    """
+
+    valid_chart_types = [
+    "spotify_viral_daily", "spotify_viral_weekly", "spotify_top_daily", "spotify_top_weekly",
+    "applemusic_top", "applemusic_daily", "applemusic_albums",
+    "itunes_top", "itunes_albums", "shazam", "beatport",
+    "youtube", "youtube_tracks", "youtube_videos", "youtube_trends", "amazon"
+    ]
+    
+    if chart_type not in valid_chart_types:
+        raise ValueError(f"Invalid chart_type '{chart_type}'. Must be one of: {valid_chart_types}")
+
+    current_state = await ctx.store.get('state')
+    print(f"value of current_state on load inside of get_chart is: {current_state}")
+
+    #https://api.chartmetric.com/api/artist/:id/:type/charts
+
+    access_token = get_chartmetric_access_token_cached()
+
+
+    print("🚀 Called get_charts with artist_id:", artist_id)
+    print("🚀 Called get_charts with access_token:", access_token)
+
+    ##shoukd make dates of the chart dynamic later
+    ##need to give chart options in function description clearly
+
+    url = f"https://api.chartmetric.com/api/artist/{artist_id}/{chart_type}/charts?since=2025-03-01&until=2025-07-04"
+    headers = {
+        "Authorization": f"Bearer {access_token}"
+    }
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        print(f"❌ Request failed with status {response.status_code}: {response.text}")
+        return {}
+        
+
+    data = response.json()
+    #print(f"data from get_charts is: {data}")
+    print("🚀 data call to get_charts successfully made!")
+
+    dataObj = data.get('obj',{})
+    #print(f"dataObj is {dataObj}")
+    dataObjEntries = dataObj.get('data',{})
+    dataObjEntries2 = dataObjEntries.get('entries',{})
+    #print(f"dataObjEntries2 is {dataObjEntries2}")
+    
+    relevant_details = []
+    for entry in dataObjEntries2:
+        print(f"entry is: {entry}")
+        stuffToSave = { "album": entry["name"], "pre-rank": entry["pre_rank"], "peak": entry["peak_rank"], "peak_day": entry["peak_date"], "rank": entry["rank"] }
+        print(f"stuff to save is: {stuffToSave}")
+        relevant_details.append(stuffToSave)
+    
+    print(f"value of relevant_dtails is: {relevant_details}")
+
+    if "working_notes" not in current_state:
+        current_state["working_notes"] = {}
+    
+    if f"charts_data for {artist_id}" not in current_state["working_notes"]:
+        current_state["working_notes"][f"charts_data for {artist_id}"] = {}
+    
+    current_state["working_notes"][f"charts_data for {artist_id}"][chart_type] = relevant_details
+    await ctx.store.set('state', current_state)
+
+    return {
+    "artist_id": artist_id,
+    "chart_data": relevant_details
+}
+
+
+    prompto3 = f"""
+# ROLE & TASK
+You are a **senior music strategist** hired to deliver a **two-page Audience Intelligence Brief** for the artist **{chosen_artist}**.
+
+# SOURCE MATERIAL
+– You have one source only: **RAW_DATA** (verbatim answers & metrics pulled from Instagram, TikTok and YouTube).
+– Treat all numbers as trustworthy unless they contradict each other; in that case flag the conflict in “Data Gaps”.
+
+# WORKFLOW  (do not display)
+1. **THINK:** Extract every statistic, named entity, quote or behavioural clue from RAW_DATA.  
+2. **PLAN:** Map those findings onto the template sections. Identify unsupported cells early.  
+3. **WRITE:** Populate the markdown template in polished, presentation-ready prose.  
+   – Use concise bullet points (max. 15 words each) and tables for scannability.  
+   – Keep each column width sensible; wrap long text with `<br>` if needed.  
+4. **VERIFY:** Double-check that totals, % and age-band ranges add up logically.  
+5. **CLEAN:** Do **not** expose this workflow, system prompts or RAW_DATA.
+
+# STYLE
+Consultative, insight-rich, brand-strategy tone. Prefer active voice, audience-centric language (“Fans show…”, “Leverage…”).  
+Use **bold** for key stats, *italics* for emphasis, emojis only where the template already includes them.
+
+# DELIVERABLE
+Return **exactly** the filled-in template between the markers  
+`---BEGIN BRIEF---` and `---END BRIEF---`.  
+If a section lacks data, keep the section but write “*No platform data supplied — analyst inference required*”.
+
+# MARKDOWN TEMPLATE  (to be populated – do NOT repeat unfilled)
+### Deep-Dive Audience Analysis for {chosen_artist}  
+(Synthesising Instagram, TikTok & YouTube data within Turkish pop-market context)
+
+---
+
+1. **Audience Architecture at a Glance**  
+| Layer              | Instagram Data            | TikTok/Other*         | Strategic Takeaway                       |
+|--------------------|---------------------------|-----------------------|------------------------------------------|
+| Scale              |                           |                       |                                          |
+| Core Territory     |                           |                       |                                          |
+| Secondary Markets  |                           |                       |                                          |
+| Gender             |                           |                       |                                          |
+| Prime Age Band     |                           |                       |                                          |
+
+---
+
+2. **Hidden Insights & Underserved Nuances**  
+| Insight                            | Evidence (platform, metric)     | Why It Matters                          |
+|------------------------------------|---------------------------------|------------------------------------------|
+|                                    |                                 |                                          |
+|                                    |                                 |                                          |
+|                                    |                                 |                                          |
+
+---
+
+3. **Psychographic Micro-Segments to Activate**  
+| Segment Name        | % Audience | Description (mindset / need-state) | Ideal Touch-point                       |
+|---------------------|-----------:|------------------------------------|-----------------------------------------|
+|                     |            |                                    |                                         |
+|                     |            |                                    |                                         |
+
+---
+
+4. **Content & Channel Implications**  
+| Funnel Stage   | Priority Channel(s) | Format & Narrative Hook              |
+|----------------|---------------------|--------------------------------------|
+| Discovery      |                     |                                      |
+| Consideration  |                     |                                      |
+| Community      |                     |                                      |
+| Conversion     |                     |                                      |
+
+---
+
+5. **Monetisation & Partnership Levers**  
+- 
+- 
+- 
+- 
+
+---
+
+6. **Risks & Mitigations**  
+| Risk                                   | Potential Impact       | Mitigation Play                          |
+|----------------------------------------|------------------------|------------------------------------------|
+|                                        |                        |                                          |
+|                                        |                        |                                          |
+
+---
+
+7. **Data Gaps & Next Steps**  
+- 
+- 
+- 
+
+---
+
+📦 **RAW_DATA** (for internal use only – do NOT show in the brief)
+{overall_answers}
+
+---BEGIN BRIEF---
+<!-- o3 starts populating here -->
+---END BRIEF---
+"""
+
+
+#and that code which allows logging of every step of the memory/thought process
+
+#keep teh cahce of chartmetric api, attached to function that gets api_key, which is inserted into each relevant api
+#find_artist_id_for_artist_tool = FunctionTool.from_function(find_artist_id_for_artist)
+#get_instagram_audience_stats_tool = FunctionTool.from_function(get_instagram_audience_stats)
+#get_similar_artists = FunctionTool.from_function(get_similar_artists)
+
+
+# Wrap your function
+#find_artist_id_for_artist_tool = FunctionTool(fn=find_artist_id_for_artist)
+#get_instagram_audience_stats_tool = FunctionTool(fn=get_instagram_audience_stats)
+#get_similar_artists_tool = FunctionTool(fn=get_similar_artists)
+
+manager_agent = ReActAgent(
+    name="ManagerAgent",
+    description="Manager agent decides which other agents to use, and is decision maker",
+    system_prompt=(
+    "You are the manager agent. You do not collect data yourself. You delegate tasks to other agents.\n\n"
+    "Your responsibilities are:\n"
+    "- Receive the user’s question\n"
+    "- Decide whether StreamingChartAgent or SocialMediaDataAgent or SimilarityAgent (or two or all) should handle the request\n"
+    "+ If the question is about social media audience data (TikTok, Instagram, YouTube), use SocialMediaDataAgent."
+"+ If the question is about chart positions, chart history, or streaming rankings, use StreamingChartAgent."
+    "- Wait for their responses and evaluate whether the question has been sufficiently answered\n"
+),
+    llm=llm,
+    can_handoff_to=["SocialMediaDataAgent", "SimilarityAgent", "StreamingChartAgent"]
+)
+
+streaming_chart_agent = ReActAgent(
+    name="StreamingChartAgent",
+    description="agent to retrieve streaming chart data for the artist being researched",
+    system_prompt=("You are a research agent that retrieves streaming chart information about an artist"),
+    llm=llm,
+    tools=[get_charts, find_artist_id_for_artist],
+    can_handoff_to=["ManagerAgent", "SimilarityAgent", "SocialMediaDataAgent"]
+)
+
+
+social_media_data_agent = ReActAgent(#try with Function Agents first, change to ReAct agents if needed/performance is poor.
+    name="SocialMediaDataAgent",
+    description="agent to source data about artists from social media data, using chartmetric api",
+    system_prompt=(
+    "You are a research agent that uses social media data to analyze artist audiences via Chartmetric.\n"
+    "- Always use **both** Instagram and TikTok and Youtube data as your default behavior when analyzing artists.\n"
+    "- Do NOT choose one over the other unless explicitly told to focus on one.\n"
+    "- Always call 'get_instagram_audience_stats' AND 'get_tiktok_audience_data' AND 'get_youtube_audience_data' when gathering audience data.\n"
+    "- Do NOT assume artist names. Only use 'find_artist_id_for_artist' with real artist names provided by the user.\n"
+    "- If the user needs information about similar artists, HAND OFF to the SimilarityAgent — do NOT attempt it yourself.\n"
+    "- Your tools are only for Instagram and TikTok and Youtube data.\n"
+)
+,
+    llm=llmHigher,
+    tools=[get_instagram_audience_data, find_artist_id_for_artist, get_tiktok_audience_data, get_youtube_audience_data],
+    can_handoff_to=["ManagerAgent", "SimilarityAgent", "StreamingChartAgent"]#allow it to handoff to all other agents
+)
+
+streaming_chart_agent = ReActAgent(
+    name="StreamingChartAgent",
+    description="agent to retrieve streaming chart data for the artist being researched",
+    system_prompt=("You are a research agent that retrieves streaming chart information about an artist"),
+    llm=llm,
+    tools=[get_charts, find_artist_id_for_artist],
+    can_handoff_to=["ManagerAgent", "SimilarityAgent", "SocialMediaDataAgent"]
+)
+
+similarity_agent = ReActAgent(
+    name="SimilarityAgent",
+    description="agent to find similar artists to the artist being research, using chartmetric api",
+    system_prompt=("You are a research agent that looks for similar artists to the artist you are researching, in order to understand how the artist can copy the growth of similar artists who are larger."
+    "you can handoff to SocialMediaDataAgent, in order to find information about the followers of similar artists"
+    ),
+    llm=llm,
+    tools=[get_similar_artists, find_artist_id_for_artist],
+    can_handoff_to=["ManagerAgent", "SocialMediaDataAgent", "StreamingChartAgent"]
+)
+
+
+
+
+
+
+
+async def main(chosen_artist, purpose_outline):
+    #response = await workflow.run(user_msg="What is Bertie Blackman's Chartmetric artist ID?"
+#, ctx=ctx) python llamaOaAgent.py
+    #chosen_artist = "Kenan Doğulu"
+
+    #llm call to generate dynamic questions, and prompt
+    questions_to_ask = generate_questions_dynamic(chosen_artist, purpose_outline)
+    
+    overall_answers = ""
+    overall_answers2 = {}
+
+    all_states = {}
+
+    for (index, user_msg) in enumerate(questions_to_ask):
+        
+        print(f"starting questions {index + 1}")
+
+        overall_answers2[index] = {"Thoughts": "", "Answer": ""}
+
+        #create/re-create workflow with new question as user_msg
+        workflow = AgentWorkflow(
+        agents=[similarity_agent, social_media_data_agent, manager_agent, streaming_chart_agent],
+        root_agent=manager_agent.name,
+        initial_state={"working_notes": {}, "user question": user_msg, "users language": "English"}
+        )
+        
+        # run the workflow with context
+        ctx = Context(workflow)
+
+
+
+
+        handler = workflow.run(user_msg=user_msg, ctx=ctx)
+        current_agent = None
+        current_tool_calls = ""
+
+        
+        
+        async for event in handler.stream_events():
+            if (
+                hasattr(event, "current_agent_name")
+                and event.current_agent_name != current_agent
+               ):
+               current_agent = event.current_agent_name
+               print(f"\n{'='*50}")
+               print(f"🤖 Agent: {current_agent}")
+               print(f"{'='*50}\n")
+            
+            elif isinstance(event, AgentOutput):
+                content = event.response.content.strip()
+                print("📤 Output:", content)
+
+        # New logic: extract Thought and Answer from any position
+                clean_answer_combined = ""
+                thought, answer = None, None
+                
+                if "Thought:" in content:
+                    if "Answer:" in content:
+                        thought = content.split("Thought:")[1].split("Answer:")[0].strip()
+                    
+                    else:
+                        thought = content.split("Thought:")[1].strip()
+                        overall_answers2[index]["Thoughts"] += "\n" + thought
+                        clean_answer_combined += f"🧠 Thought: {thought}\n"
+                    
+                if "Answer:" in content:
+                    answer = content.split("Answer:")[-1].strip()
+                    overall_answers2[index]["Answer"] = answer
+                    clean_answer_combined += f"✅ Answer: {answer}\n"
+
+                if clean_answer_combined:
+                    question_header = f"\n### Q{index + 1}: {user_msg}\n"
+                    overall_answers += question_header + clean_answer_combined + "\n"
+                
+                # If either Thought or Answer was captured, append to overall_answers
+       
+                if event.tool_calls:
+                    print(
+                        "🛠️  Planning to use tools:",
+                        [call.tool_name for call in event.tool_calls],
+                        )
+                elif isinstance(event, ToolCallResult):
+                    print(f"🔧 Tool Result ({event.tool_name}):")
+                    print(f"  Arguments: {event.tool_kwargs}")
+                    print(f"  Output: {event.tool_output}")
+                elif isinstance(event, ToolCall):
+                    print(f"🔨 Calling Tool: {event.tool_name}")
+                    print(f"  With arguments: {event.tool_kwargs}")
+        
+        state = await ctx.store.get("state")
+        all_states[f"Q{index+1}"] = {
+            "question": user_msg,
+            "state": state
+            }
+        
+    print(f"overall_answers is: {overall_answers}")
+
+    #final_state = await ctx.store.get("state")
+        
+    with open(f"ctx_memory_all_answersDynamic.json", "w") as f:
+        json.dump(all_states, f, indent=2)
+    
+    #can then keep just the last thought of each question index
+
+    def count_tokens(text, model="gpt-4o"):
+        encoding = tiktoken.encoding_for_model(model)
+        return len(encoding.encode(text))
+    
+    total_tokens = count_tokens(overall_answers)
+    print(f"Total tokens of overall_answers: {total_tokens}")
+
+    
+# Build a single string
+    flattened = "\n\n".join(
+        f"Q{idx + 1}: {qa['Thoughts']}\n{qa['Answer']}" 
+        for idx, qa in overall_answers2.items()
+    )
+
+    total_tokens2 = count_tokens(flattened)
+    print(f"Total tokens of overall_answers2: {total_tokens2}")
+
+    with open(f"overall_answersGemini.txt","w", encoding="utf-8") as file:
+        file.write(overall_answers)
+    
+    with open(f"overall_answers2Gemini.txt","w", encoding="utf-8") as file:
+        json.dump(overall_answers2, file, ensure_ascii=False, indent=2)
+
+
+
+    #now send overall_answers to LLM
+   
+
+  
+
+    prompto3ChrisChart = f"""🎯 MEGA AUDIENCE INSIGHT & GROWTH PROMPT
+Prompt Title: Deep Audience Intelligence & Growth Blueprint for [ARTIST_NAME]
+
+System Role (Set Once):
+You are a senior music data strategist trained in multi-platform audience intelligence, behavioral segmentation, and growth marketing. You operate like a hybrid of a data analyst, music marketer, and product strategist. Your job is to extract unique insights, detect overlooked opportunities, and build a data-driven growth plan for the artist based on a rich dataset of streaming, chart, and social data.
+
+🔍 INPUT DATA:
+Structured streaming data (Spotify, Apple Music, iTunes, Shazam) with rank movement, peak days, velocity, and decay.
+
+Social media + CRM metrics (TikTok, IG, YouTube, Reels, Stories, Email, Merch, Tour Sales, etc.).
+
+Any artist metadata you can derive (track names, album release cycles, remix info, sentiment cues, genre tags, collaborators).
+
+🧠 TASK
+Split your approach into three distinct cognitive layers, executed in sequence:
+
+✅ LAYER 1: ANALYTICAL DEEP DIVE
+Understand the data in its rawest form.
+
+Detect patterns in streaming velocity, seasonal performance, and Shazam conversion.
+
+Surface anomalies — outlier peaks, remix vs original inconsistencies, platform skews.
+
+Build segmentations across:
+
+Demographics (inferred via geo and platform)
+
+Behavioral (engagement, replay rate, completion, skip/save behavior)
+
+Content type affinity (e.g., club mix vs acoustic vs emotional lyrics)
+
+Identify:
+
+Top 3–5 most influential formats (content, platform, track type)
+
+2–3 examples of platform crossover lags (e.g., Shazam peak → Spotify delay)
+
+Fanbase decay curves (where and when attention drops off)
+
+🧠 LAYER 2: STRATEGIC REASONING
+Generate hypotheses and opportunity clusters.
+
+Audience Gaps:
+
+Where is the artist underperforming?
+
+What similar audiences (adjacent genres, demos, cities) are reachable?
+
+Cluster Fans into Personas based on behavior + geo:
+Example labels:
+
+“Shazam-driven club-goers in Southern Europe”
+
+“Loyal iTunes buyers over 40 in Central Asia”
+
+“Spotify Weekly repeaters with remix preference in Berlin”
+
+For each persona cluster, answer:
+
+What drives their behavior?
+
+Where can we find more like them?
+
+Which platform(s) matter most?
+
+Propose 3–4 testable hypotheses about:
+
+Timing strategies
+
+Collaboration types
+
+Format performance
+
+Messaging tones (e.g. romantic, nostalgic, rebellious)
+
+🚀 LAYER 3: GROWTH & CAMPAIGN STRATEGY
+Turn intelligence into a tactical plan.
+
+Recommend:
+
+3 platform strategies, tailored to audience types (e.g. TikTok + Reels = Hook virality vs Apple = intimacy/purchase)
+
+3 content types likely to resonate with segments (e.g. stripped vocals for Gen Z on IG vs remix packs for DJs)
+
+2 partnership ideas — either influencer-led, playlist curators, or collab artists with overlapping fanbases
+
+Suggest distribution timing:
+
+What day, week, and month clusters have historically driven best results?
+
+Layer this with social engagement cycles.
+
+Design 1 bold, data-informed “Big Bet” campaign:
+
+Could be a geo-targeted drop, genre mashup collab, remix competition, or a multi-platform narrative series.
+
+🧪 OUTPUT FORMAT:
+markdown
+Copy
+Edit
+# Artist Audience Intelligence & Growth Blueprint: [Artist Name]
+
+## 1. Overview
+Short summary of overall patterns, growth arcs, and platform behaviors.
+
+## 2. Key Segments
+- Persona 1: “...” → Description, platforms, geo, behavior
+- Persona 2: ...
+- Persona 3: ...
+
+## 3. Strategic Observations
+- Opportunity gaps
+- Surprising over/under performance
+- Hypotheses
+
+## 4. Marketing Recommendations
+### A. Platform Strategy
+[List of 3, each with logic and examples]
+
+### B. Content Types to Emphasize
+[List of 3, with reasoning per segment]
+
+### C. Influencer/Partnership Strategy
+[2 ideas with audience alignment logic]
+
+## 5. Big Bet Growth Campaign
+Title + concept + rationale
+
+Your data is {overall_answers}
+"""
+
+
+
+
+
+    
+    ##cut down Thought input, so only last one returned with Answer from
+
+
+    #count tokens anyway, for later usage:
+    total_tokens = count_tokens(purpose_outline)
+    print(f"Total tokens of prompt: {total_tokens}")
+
+    max_tokens = 16384 - total_tokens - 200
+    
+    final_prompt = purpose_outline + f"""Your sole data source should be: {overall_answers}""" + f"""The artist is: {chosen_artist}"""
+    
+    response = client.responses.create(
+    model="o3",
+    input=[
+        {
+            "role": "developer",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": (
+                        "You are a precise music industry data analyst. "
+                        "Be structured, factual, and preserve all stats given."
+                    )
+                }
+            ]
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": final_prompt
+                }
+            ]
+        }
+    ],
+    text={
+        "format": {
+            "type": "text"
+        }
+    },
+    reasoning={
+        "effort": "medium",
+        "summary": "auto"
+    },
+    tools=[],
+    store=True
+    )
+
+    
+    print(response.output_text)
+    two_pager_document = response.output_text
+    
+
+    #Gemini version
+    #enai.configure(api_key="AIzaSyBtpgpnI_kzxPfvlqoDbaYwlOPdxI89qNI")
+    #model = genai.GenerativeModel("models/gemini-2.5-pro")
+
+# Generate content
+    #responseGemini = model.generate_content(f"You are a precise music industry data analyst. Be structured, factual, and preserve all stats given. use: {final_prompt}")
+    #two_pager_gemini = responseGemini.text
+
+
+    #print(responseGemini.text)
+
+    
+    #for question in formal_questions:
+    #print(f"overall_answer2 is {overall_answers2}")
+
+    with open(f"{chosen_artist}DynamicQuestionsOpenAI.txt","w", encoding="utf-8") as file:
+        file.write(two_pager_document)
+    
+    return two_pager_document
+
+
+demo = gr.Interface(
+    fn=main,
+    inputs=["text", "text"],
+    outputs="text",
+    title="artist report generator - dynamic questions",
+    description="generate report for artist"
+)
+
+demo.launch(share=True)
+
+#if __name__ == "__main__":
+    #response = asyncio.run(main())
+    #then pass to llm to assemble formal response to formal questions
+
+# FunctionAgent works for LLMs with a function calling API.
+# ReActAgent works for any LLM.
+
+
+
+#can check logs:
+#async for ev in handler.stream_events():
+    #if isinstance(ev, ToolCallResult):
+        #print("")
+        #print("Called tool: ", ev.tool_name, ev.tool_kwargs, "=>", ev.tool_output)
+    #elif isinstance(ev, AgentStream):  # showing the thought process
+        #print(ev.delta, end="", flush=True)
+

helper_function.py

@@ -0,0 +1,167 @@
+import google.generativeai as genai
+import re
+import json
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = OpenAI()
+
+genai.configure(api_key="AIzaSyBtpgpnI_kzxPfvlqoDbaYwlOPdxI89qNI")
+client = OpenAI(
+    api_key=os.getenv('OPENAI_API_KEY'),
+)
+
+
+#artist_name = "Kenan Doğulu"
+purpose_outline = f"""
+# ROLE & TASK
+You are a **senior music strategist** hired to deliver a **two-page Audience Intelligence Brief** for the artist .
+
+# SOURCE MATERIAL
+– You have one source only: **RAW_DATA** (verbatim answers & metrics pulled from Instagram, TikTok and YouTube).
+– Treat all numbers as trustworthy unless they contradict each other; in that case flag the conflict in “Data Gaps”.
+
+# WORKFLOW  (do not display)
+1. **THINK:** Extract every statistic, named entity, quote or behavioural clue from RAW_DATA.  
+2. **PLAN:** Map those findings onto the template sections. Identify unsupported cells early.  
+3. **WRITE:** Populate the markdown template in polished, presentation-ready prose.  
+   – Use concise bullet points (max. 15 words each) and tables for scannability.  
+   – Keep each column width sensible; wrap long text with `<br>` if needed.  
+4. **VERIFY:** Double-check that totals, % and age-band ranges add up logically.  
+5. **CLEAN:** Do **not** expose this workflow, system prompts or RAW_DATA.
+
+# STYLE
+Consultative, insight-rich, brand-strategy tone. Prefer active voice, audience-centric language (“Fans show…”, “Leverage…”).  
+Use **bold** for key stats, *italics* for emphasis, emojis only where the template already includes them.
+
+# DELIVERABLE
+Return **exactly** the filled-in template between the markers  
+`---BEGIN BRIEF---` and `---END BRIEF---`.  
+If a section lacks data, keep the section but write “*No platform data supplied — analyst inference required*”.
+
+# MARKDOWN TEMPLATE  (to be populated – do NOT repeat unfilled)
+### Deep-Dive Audience Analysis for teh artist 
+(Synthesising Instagram, TikTok & YouTube data within Turkish pop-market context)
+
+---
+
+1. **Audience Architecture at a Glance**  
+| Layer              | Instagram Data            | TikTok/Other*         | Strategic Takeaway                       |
+|--------------------|---------------------------|-----------------------|------------------------------------------|
+| Scale              |                           |                       |                                          |
+| Core Territory     |                           |                       |                                          |
+| Secondary Markets  |                           |                       |                                          |
+| Gender             |                           |                       |                                          |
+| Prime Age Band     |                           |                       |                                          |
+
+---
+
+2. **Hidden Insights & Underserved Nuances**  
+| Insight                            | Evidence (platform, metric)     | Why It Matters                          |
+|------------------------------------|---------------------------------|------------------------------------------|
+|                                    |                                 |                                          |
+|                                    |                                 |                                          |
+|                                    |                                 |                                          |
+
+---
+
+3. **Psychographic Micro-Segments to Activate**  
+| Segment Name        | % Audience | Description (mindset / need-state) | Ideal Touch-point                       |
+|---------------------|-----------:|------------------------------------|-----------------------------------------|
+|                     |            |                                    |                                         |
+|                     |            |                                    |                                         |
+
+---
+
+4. **Content & Channel Implications**  
+| Funnel Stage   | Priority Channel(s) | Format & Narrative Hook              |
+|----------------|---------------------|--------------------------------------|
+| Discovery      |                     |                                      |
+| Consideration  |                     |                                      |
+| Community      |                     |                                      |
+| Conversion     |                     |                                      |
+
+---
+
+5. **Monetisation & Partnership Levers**  
+- 
+- 
+- 
+- 
+
+---
+
+6. **Risks & Mitigations**  
+| Risk                                   | Potential Impact       | Mitigation Play                          |
+|----------------------------------------|------------------------|------------------------------------------|
+|                                        |                        |                                          |
+|                                        |                        |                                          |
+
+---
+
+7. **Data Gaps & Next Steps**  
+- 
+- 
+- 
+
+---
+
+
+
+---BEGIN BRIEF---
+<!-- o3 starts populating here -->
+---END BRIEF---
+"""
+
+#llm call to generate list of questions and prompt
+#do so seperrekt
+
+
+
+
+
+
+
+def generate_questions_dynamic(artist_name, prompt):
+    #model = genai.GenerativeModel("models/gemini-2.5-pro")
+    message = f"""Using the purpose_outline passed to you, you need to generate a series of questions of as many questions as you think are neccessary to fulfill the outline.
+
+
+The following tools are available to answer the questions you generate: get_tiktok_audience_data, get_instagram_audience_data, get_youtube_audience_data, get_similar_artists, get_charts.
+You should generate questions that can axctually be answered with the tools available to you.
+
+You should return the questions in the format: ["question 1", "question 2", "question 3"]. NO NUMBERS, STRICTLY THAT SCHEMA. No more than 10, no less than 7 questions.
+
+Context:
+The artist is: {artist_name}
+The purpose_outline is: {prompt}
+
+"""  # Generate content
+    #response_gemini = model.generate_content(message)
+    response = client.responses.create(
+    model="gpt-4o",
+    input=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": message}
+    ],
+    temperature=0.7
+    )
+
+  
+
+    questions = response.output_text
+    print(f"response_gemini is: {questions}")
+    questions_to_ask = questions
+    print(f"questions_to_ask are: {questions_to_ask}")
+     
+    stripped_questions_to_ask = re.sub(r"^```json\s*|\s*```$", "", questions_to_ask.strip())
+    print(f"post-stripping: {stripped_questions_to_ask}")
+     
+    questions_to_ask_cleaned = json.loads(stripped_questions_to_ask)
+    print(f"questions_to_ask_cleaned is: {questions_to_ask_cleaned}")
+    return questions_to_ask_cleaned
+
+#generate_questions_dynamic("Kenan Doğulu", purpose_outline)

requirements.txt

@@ -0,0 +1,9 @@
+llama-index-core==0.13.0
+llama-index-llms-openai==0.5.0
+openai==1.81.0
+tiktoken
+python-dotenv
+requests
+gradio
+transformers
+google-generativeai