Sample Finder

I want to build a task which will input a broad description of the type of music I want to sample (perhaps key, tempo, style, previous artists who sampled it, instrumentation I want, etc), and run searches and visit music/sample websites or APIs and return a list of songs - with youtube links for them - that I can sample

Sub Agent #1 | Sub Agent #2 | Sub Agent #3

CLAUDE:- final-output-and-component-outputs

a) The final output of the task you described would be a list of songs that match your specified criteria, along with YouTube links for each song. The list would likely be in a text format, such as a plain text file, a CSV file, or a JSON file, depending on your preference and the requirements of your AI agent. The essential information in the output would include:

- Song title
- Artist name
- YouTube link to the song
- Possibly additional metadata like tempo, key, instrumentation, etc.

b) Breaking down the task into components, the following core outputs would be needed:

1. User Input:
   - A structured format (e.g., JSON or a form) to capture the user's preferences, such as key, tempo, style, previous artists who sampled it, desired instrumentation, etc.

2. Search Query Generator:
   - A component that takes the user input and generates search queries tailored to various music/sample websites or APIs.

3. Web Scraper or API Client:
   - A component that visits the music/sample websites or interacts with their APIs using the generated search queries.
   - It should extract relevant information from the search results, such as song titles, artist names, and YouTube links.

4. Data Aggregator:
   - A component that collects and aggregates the data obtained from multiple sources (websites or APIs).
   - It should handle data cleaning, deduplication, and ensuring consistency in the format of the collected information.

5. Output Generator:
   - A component that takes the aggregated data and generates the final output file (e.g., text file, CSV, or JSON) containing the list of songs and their corresponding YouTube links.
   - The output should be structured and follow a consistent format for easy parsing and utilization by the user or other systems.

6. Error Handling and Logging:
   - Components to handle errors that may occur during the search, scraping, or API interactions.
   - Logging functionality to track the progress, errors, and any relevant information for debugging and monitoring purposes.

7. User Interface (optional):
   - If desired, a user interface component to provide a friendly way for users to input their preferences and view the generated song list.
   - This could be a command-line interface, a web-based interface, or integrated into an existing application, depending on your requirements.

These components work together to create a workflow that takes user input, searches for relevant songs across various sources, aggregates the data, and generates a structured output file containing the list of songs with their YouTube links, which can be used for sampling purposes.

GPT4:- final-output-and-component-outputs

a) The final output for this task would be a curated list of songs, along with their respective YouTube links, that match the specified criteria (key, tempo, style, previous artists who sampled it, instrumentation, etc.). Each entry in the list would represent a single song you may sample and may also include additional details like music sample website or API information, artist's name, album, and more, depending on specifics of the task requirements.

b) The core components for generating this final output could include:

1. Search Criteria: Specific details related to the type of music to be sampled - such as key, tempo, style, previous artists who sampled it, instrumentation, etc. - that will be inputted into the AI agent.

2. Source APIs/Websites: Records of music/sample websites or APIs that the AI agent will visit to search for songs matching the provided criteria. These might include platforms like SoundCloud, Spotify, WhoSampled, API databases like the MusicBrainz API, or commercial music databases.

3. Web Scraping/Search Algorithm: A mechanism by which the AI agent can search the source APIs/websites, process them, and identify songs that match the search criteria. This might involve sophisticated query formation, web scraping, and data extraction techniques.

4. Song Identification and Data Extraction: Systems for precisely identifying and extracting the correct songs and associated data (such as the artist, album, etc.) from the search results.

5. YouTube Link Generator: It would be the component that finds and extracts the YouTube links for each identified song. This could involve calling the YouTube Data API and searching for the song's details or scraping YouTube Web.

6. Output Formatter: This is the final assembler that takes all the information identified and retrieved by the AI - the song match list and the corresponding YouTube links - and arranges all this data into a readable, user-friendly format. This could be, for instance, a word or excel document, JSON file, or even a database entry depending on your needs.

claude 3 - extract final output

extract component outputs

1. User Input:
   - A structured format (e.g., JSON or a form) to capture the user's preferences, such as key, tempo, style, previous artists who sampled it, desired instrumentation, etc.

2. Search Query Generator:
   - A component that takes the user input and generates search queries tailored to various music/sample websites or APIs.

Claude - research-ideas-and-input-variables

Thank you for the detailed prompt and questions. Let me address each of them in turn:

a) To clarify the final output of the task, I would ask the following questions:
- How many songs should be returned in the final list?
- Should the list include just the song names and YouTube links, or do you also want additional information such as the artist, year, genre, BPM, key, etc.?
- Are there any specific music/sample websites or APIs you want me to focus on, or should I search broadly across the web?
- What format would you like the final output in? A text list, a spreadsheet, a database, or something else?

b) Before launching the task completion process, the Agent should accept the following inputs:
- A description of the desired music style, including any or all of: key, tempo, genre, instrumentation, mood, etc.
- Examples of artists or songs that have the desired style/sound
- Any specific songs or samples you already know you want included
- The desired number of songs to be returned
- Any specific websites or APIs to focus on

c) I have no strong insights or suggestions as to how we might want to silo and segment any of the core tasks in this case. The task seems fairly well-defined and focused: searching for and compiling a list of songs based on certain criteria. The main steps would be:
1. Parse the input criteria 
2. Search websites and APIs for matching songs
3. Compile the results into the desired output format
4. Deliver the output

The only potential segmentation I could see being helpful is if you wanted to separate the instrumental and vocal tracks for each song. In that case, there could be a separate task after finding each song to search for and download the individual stems. But in general, I think this workflow could be executed straightforwardly without much need for segmentation. The key will be crafting the search queries carefully based on the input criteria to get the most relevant results.

Let me know if you have any other questions! I'm happy to clarify or elaborate on any part of my response.

GPT - research-ideas-and-input-variables

a) To clarify the final output of the task, I might ask the following questions:

1. How specific do you want the songs suggestions to be with respect to the provided parameters? Will generic suggestions be acceptable or should each provided parameter closely match the returned song?
2. What format would you like the final list of songs to be presented in? For example, a spreadsheet, a word document, or a simple list.
3. How many song suggestions do you expect in the final output?
4. Do you want the final list to only include songs that are free to use or sample or are copyrighted songs also acceptable? 
5. Do you want the AI to provide any additional information about the songs such as the artist, album, or year it was produced?
6. Do you want the AI to also provide download or purchase links where possible?
7. If multiple songs are from the same artist, do you prefer them to be clustered together, or would you rather have a diverse list?

b) Before launching the task completion process, the AI Agent should accept the following inputs:

1. The type of music or genre in which the user is interested.
2. Key details like tempo, style of music and preferred instrumentation.
3. Names of previous artists or songs that have been sampled to guide the search.
4. The maximum and minimum number of songs that should be returned.
5. Whether it should only return songs with youtube links or if other music platforms are acceptable.
6. If there is any specific source (like a particular music/sample website or database) preferred for the search.
7. Any restrictions on copyright or use of the music.
8. Any other specific preferences or locational requirements, such as minimal vocals, a particular language, or sound production quality.

template-ideas

Based on the task you described and the considerations for selecting templates, here are some suggestions for templates that could help refine the definition of a successful output:

1. Music streaming platform search results:
   - Visit popular music streaming platforms like Spotify, Apple Music, or SoundCloud.
   - Search for songs using keywords related to your desired criteria (e.g., tempo, key, instrumentation, genre).
   - Analyze the search results and note the format and information provided, such as song title, artist name, album, release year, and any additional metadata.
   - This template will give you an idea of how music data is typically presented and what information is relevant.

2. Music sampling websites:
   - Explore websites that offer music samples, such as Splice, Loopmasters, or Tracklib.
   - Browse their sample packs or individual samples and observe how they present the information.
   - Take note of the metadata they provide, such as tempo, key, genre, instrumentation, and sample length.
   - This template will help you understand the common format and information used in the music sampling industry.

3. YouTube search results:
   - Perform searches on YouTube using keywords related to your desired criteria.
   - Analyze the search results and observe the information displayed, such as video title, channel name, view count, and video duration.
   - Pay attention to how the results are ranked and what additional information is provided, such as video descriptions and tags.
   - This template will give you insights into how YouTube presents music-related content and what information is typically included.

4. Music database APIs:
   - Research popular music database APIs like MusicBrainz, Discogs, or Last.fm.
   - Review their documentation and explore the data formats they use when returning song information.
   - Take note of the fields and metadata they provide, such as song title, artist name, album, genre, release year, and any additional tags or identifiers.
   - This template will help you understand the standard data structures used in music databases and APIs.

5. Music-related Reddit threads or forum discussions:
   - Search for Reddit threads or forum discussions where people ask for song recommendations based on specific criteria.
   - Analyze the responses and observe how people describe and recommend songs.
   - Take note of the information they provide, such as song title, artist name, YouTube links, and any additional context or descriptions.
   - This template will give you an idea of how music enthusiasts and communities share and discuss song recommendations.

By collecting and analyzing these templates, you can gain a better understanding of how music-related information is typically presented, what metadata is commonly used, and how people search for and recommend songs based on specific criteria. This will help you refine your definition of a successful output and ensure that your AI agent delivers results that align with industry standards and user expectations.

claude 3 - searches

Here are 5 specific keyphrases for you to search to help refine the definition of a successful output for your task:

1. "spotify search results hip hop songs 90 bpm"
   This search will provide examples of how Spotify presents search results for songs matching specific criteria like genre and tempo.

2. "splice sample pack 80s synth pop"
   This search will show how music sampling websites like Splice present their sample packs, including relevant metadata and descriptions.

3. "youtube search results lofi hip hop study beats"
   This search will demonstrate how YouTube displays search results for a specific genre and style of music, including video titles, descriptions, and additional information.

4. "musicbrainz api example response michael jackson thriller"
   This search will provide an example of the data format and fields returned by the MusicBrainz API for a specific song, helping to understand the standard metadata used in music databases.

5. "reddit thread looking for songs similar to daft punk around the world"
   This search will uncover a Reddit thread where users are asking for song recommendations based on a specific track, showcasing how music enthusiasts describe and share song suggestions.

By searching for these specific keyphrases, you should be able to find relevant templates that will help refine your understanding of what a successful output for your task might look like. These templates will provide insights into how music-related information is typically presented, what metadata is commonly used, and how people search for and recommend songs based on specific criteria.

subagent-summary

A) FULL TASK SUMMARY: Create an AI-powered system that generates a list of songs suitable for sampling based on user-specified criteria.

B) FINAL TASK OUTPUT: A structured data file (e.g., JSON, CSV, or text file) containing a list of songs with their titles, artist names, YouTube links, and relevant metadata (tempo, key, instrumentation, etc.), tailored to the user's sampling preferences.

C) COMPONENTS OVERVIEW:
1. User Input Component
2. Search Query Generator
3. Web Scraper or API Client
4. Data Aggregator
5. Output Generator
6. Error Handling and Logging
7. User Interface (optional)

D) OVERVIEW OF SUBAGENTS:
- User Input Agent: Collects and validates user preferences for sampling criteria.
- Query Generator Agent: Generates search queries based on user input.
- Web Scraper Agent: Scrapes music/sample websites for song information.
- API Client Agent: Interacts with music/sample APIs to retrieve song data.
- Data Aggregator Agent: Aggregates and cleans data from multiple sources.
- Output Generator Agent: Generates the final structured output file.
- Error Handler Agent: Handles errors and logs relevant information.
- UI Agent (optional): Provides a user interface for input and output.

E) SUBAGENT 1: User Input Agent
- Name: User Preference Collector
- Final Output: Structured user preferences (e.g., JSON or dictionary)
- Accomplishment: The agent will create a user input form or prompt to collect the user's sampling preferences, such as key, tempo, style, previous artists, and desired instrumentation. It will validate the input and store it in a structured format for further processing.
- Sequence: Display input form > Collect user input > Validate input > Store structured preferences

F) SUBAGENT 2: Query Generator Agent
- Name: Search Query Crafter
- Final Output: List of search queries tailored to different music/sample websites or APIs
- Accomplishment: The agent will take the structured user preferences and generate search queries suitable for various music/sample websites or APIs. It will consider the specific requirements and formats of each target platform to create optimized queries.
- Sequence: Load user preferences > Generate queries for each platform > Store generated queries

G) SUBAGENT 3: Web Scraper Agent
- Name: Music Website Scraper
- Final Output: Scraped song data (title, artist, YouTube link, metadata) from multiple websites
- Accomplishment: The agent will use the generated search queries to scrape relevant music/sample websites. It will navigate through the pages, locate the required song information, and extract it using web scraping techniques (e.g., BeautifulSoup, Scrapy).
- Sequence: Load search queries > Scrape websites > Extract song data > Store scraped data

H) SUBAGENT 4: API Client Agent
- Name: Music API Interactor
- Final Output: Retrieved song data (title, artist, YouTube link, metadata) from multiple APIs
- Accomplishment: The agent will use the generated search queries to interact with various music/sample APIs. It will make API requests, handle authentication if required, and retrieve relevant song data from the API responses.
- Sequence: Load search queries > Make API requests > Handle API responses > Extract song data > Store retrieved data

I) SUBAGENT 5: Data Aggregator Agent
- Name: Song Data Aggregator
- Final Output: Aggregated and cleaned song data from multiple sources
- Accomplishment: The agent will collect the song data obtained from the Web Scraper Agent and API Client Agent. It will perform data cleaning, handle duplicates, and ensure a consistent format for the aggregated data.
- Sequence: Load scraped and retrieved data > Clean and preprocess data > Remove duplicates > Standardize format > Store aggregated data

J) SUBAGENT 6: Output Generator Agent
- Name: Structured Output Creator
- Final Output: Structured data file (e.g., JSON, CSV, or text file) containing the list of songs
- Accomplishment: The agent will take the aggregated song data and generate the final structured output file. It will format the data according to the chosen file type (e.g., JSON, CSV) and ensure that the output is well-structured and easily parsable.
- Sequence: Load aggregated song data > Format data into chosen file type > Generate structured output file > Save output file

K) SUBAGENT 7: Error Handler Agent
- Name: Exception Catcher and Logger
- Final Output: Error logs and graceful error handling
- Accomplishment: The agent will handle errors and exceptions that may occur during the execution of other agents. It will catch exceptions, log relevant information (e.g., error messages, timestamps), and ensure graceful error handling to prevent the system from crashing.
- Sequence: Monitor other agents > Catch exceptions > Log error details > Handle errors gracefully > Continue or terminate execution as needed

L) SUBAGENT 8 (optional): UI Agent
- Name: User Interface Provider
- Final Output: User-friendly interface for input and output
- Accomplishment: The agent will create a user interface (e.g., command-line, web-based, or integrated into an existing application) to facilitate user interaction. It will provide an intuitive way for users to input their sampling preferences and display the generated song list.
- Sequence: Design user interface > Implement input form > Integrate with User Input Agent > Display generated song list > Handle user interactions

subagent-summary-amended-for-actual-tasks

Based on the updated list of available tasks, here are the revised subagents that will work together to complete the task of generating a list of songs suitable for sampling based on user-specified criteria:

SUBAGENT 1: Search Query Generator
- Final Output: List of search queries tailored to different music/sample websites or APIs
- Accomplishment: The agent will take the structured user preferences and generate search queries suitable for various music/sample websites or APIs. It will consider the specific requirements and formats of each target platform to create optimized queries.
- Sequence:
  1. Use GPT4 (Task 1) to analyze user preferences and generate search queries for each platform
  2. Store generated queries using Save content to server (Task 9)

SUBAGENT 2: Music Website Scraper
- Final Output: Scraped song data (title, artist, YouTube link, metadata) from multiple websites
- Accomplishment: The agent will use the generated search queries to scrape relevant music/sample websites. It will navigate through the pages, locate the required song information, and extract it using web scraping techniques.
- Sequence:
  1. Load search queries using Access text files already saved (Task 10)
  2. Use Search Google (Task 15) to find relevant music/sample websites
  3. Use Scrape text content of website (Task 16) and Scrape links from website (Task 17) to extract song data from the websites
  4. Store scraped data using Save content to server (Task 9)

SUBAGENT 3: YouTube Link Extractor
- Final Output: YouTube links for the scraped songs
- Accomplishment: The agent will extract YouTube links for the songs obtained from the Music Website Scraper. It will search for each song on YouTube and retrieve the corresponding video links.
- Sequence:
  1. Load scraped song data using Access text files already saved (Task 10)
  2. Use Search Google (Task 15) or a custom YouTube search API (REQUIRED) to find YouTube links for each song
  3. Store YouTube links using Save content to server (Task 9)

SUBAGENT 4: Data Aggregator
- Final Output: Aggregated and cleaned song data from multiple sources
- Accomplishment: The agent will collect the song data obtained from the Music Website Scraper and YouTube Link Extractor. It will perform data cleaning, handle duplicates, and ensure a consistent format for the aggregated data.
- Sequence:
  1. Load scraped song data and YouTube links using Access text files already saved (Task 10)
  2. Use GPT4 (Task 1) to clean and preprocess data, remove duplicates, and standardize the format
  3. Store aggregated data using Save content to server (Task 9)

SUBAGENT 5: Output Generator
- Final Output: Structured data file (e.g., JSON, CSV, or text file) containing the list of songs
- Accomplishment: The agent will take the aggregated song data and generate the final structured output file. It will format the data according to the chosen file type (e.g., JSON, CSV) and ensure that the output is well-structured and easily parsable.
- Sequence:
  1. Load aggregated song data using Access text files already saved (Task 10)
  2. Use GPT4 (Task 1) to format data into the chosen file type (e.g., JSON, CSV)
  3. Generate structured output file using Save content to server (Task 9)

SUBAGENT 6: Error Handler
- Final Output: Error logs and graceful error handling
- Accomplishment: The agent will handle errors and exceptions that may occur during the execution of other agents. It will catch exceptions, log relevant information (e.g., error messages, timestamps), and ensure graceful error handling to prevent the system from crashing.
- Sequence:
  1. Monitor other agents and catch exceptions using custom error handling and logging functionality (REQUIRED)
  2. Log error details using Save content to server (Task 9)
  3. Handle errors gracefully and continue or terminate execution as needed

Note: The initial user input is assumed to be provided through a user interface, which is not listed as a separate subagent.

random-autocomplete

To achieve the end goal of generating a list of songs that match your specified criteria, along with their corresponding YouTube links, the most relevant tasks might be:

1. Develop a user interface to input the desired music criteria (key, tempo, style, previous artists who sampled it, instrumentation, etc.).
2. Connect to music databases and APIs to search for songs based on the provided criteria.
3. Extract relevant song information from the search results, such as song title, artist name, and additional metadata.
4. Use the YouTube API to search for the corresponding YouTube links for each song.
5. Compile the song information and YouTube links into a structured format (e.g., CSV, JSON, or plain text).
6. Present the final output to you in a user-friendly manner.

The overall sequence of actions would be:

1. Create a user interface: Design and implement a user interface that allows you to input the desired music criteria easily.
2. Receive user input: Capture the music criteria entered by you through the user interface.
3. Connect to music databases and APIs: Establish connections to various music databases and APIs that contain information about songs, such as Spotify API, Last.fm API, or MusicBrainz API.
4. Search for songs: Use the provided music criteria to search for matching songs within the connected databases and APIs.
5. Extract song information: From the search results, extract relevant information for each song, including the title, artist name, and any available metadata like tempo, key, or instrumentation.
6. Fetch YouTube links: Utilize the YouTube API to search for the corresponding YouTube links for each song based on the song title and artist name.
7. Compile the output: Organize the extracted song information and YouTube links into a structured format, such as a CSV file, JSON file, or plain text document.
8. Present the results: Display the final output to you in a user-friendly manner, either through the user interface or by saving the output file to a designated location.

By following this sequence of actions, the AI Agent can effectively complete the task of generating a list of songs that match your specified criteria, along with their YouTube links, based on the information available through various music databases, APIs, and the YouTube API.

claude 3 - mermaid-for-all

SubAgent #1

claude 3 - subagent1

subagent1-refined

A) SUBAGENT SUMMARY: The Search Query Generator subagent takes structured user preferences and generates optimized search queries for various music/sample websites and APIs.

B) FINAL TASK OUTPUT: A JSON file containing a list of search queries, each tailored to a specific music/sample website or API. The JSON file will have the following structure:

{
  "queries": [
    {
      "platform": "platform1",
      "query": "generated search query for platform1"
    },
    {
      "platform": "platform2",
      "query": "generated search query for platform2"
    },
    ...
  ]
}

C) SUBAGENT INPUT:
- Structured user preferences in JSON format, including:
  - Key
  - Tempo
  - Style
  - Previous artists who sampled the desired music
  - Desired instrumentation

D) SUBAGENT TASK SUMMARY:
1. Input: Receive structured user preferences in JSON format
2. Action: Use GPT4 (Task 1) to analyze user preferences and generate a list of relevant keywords and phrases
3. Action: Use GPT4 (Task 1) to research the specific requirements and formats of each target music/sample website or API
4. Action: Use GPT4 (Task 1) to generate optimized search queries for each platform based on the user preferences and platform requirements
5. Action: Structure the generated search queries into a JSON format
6. Output: Save the JSON file containing the generated search queries using Save content to server (Task 9)

E) SILOS:
Silo 1: Keyword and Phrase Generation
- Input: Structured user preferences in JSON format
- Action: Use GPT4 (Task 1) to analyze user preferences and generate a list of relevant keywords and phrases
- Output: List of relevant keywords and phrases

Silo 2: Platform Requirements Research
- Input: List of target music/sample websites and APIs
- Action: Use GPT4 (Task 1) to research the specific requirements and formats of each target platform
- Output: Structured information about each platform's search requirements and formats

Silo 3: Search Query Generation
- Input: User preferences, relevant keywords and phrases, and platform requirements
- Action: Use GPT4 (Task 1) to generate optimized search queries for each platform
- Output: List of generated search queries for each platform

Silo 4: JSON Structuring and Output
- Input: List of generated search queries for each platform
- Action: Structure the generated search queries into a JSON format
- Action: Save the JSON file containing the generated search queries using Save content to server (Task 9)
- Output: JSON file URL containing the generated search queries

subagent1refined-repeating

G) FULL TASKS (INCLUDING REPEATING TASKS):

1. Receive structured user preferences in JSON format
2. Use GPT4 (Task 1) to analyze user preferences and generate a list of relevant keywords and phrases
3. Research and compile a list of target music/sample websites and APIs
4. Use GPT4 (Task 1) to research the specific requirements and formats of the first target platform
5. Use GPT4 (Task 1) to generate an optimized search query for the first platform based on the user preferences and platform requirements
6. Use GPT4 (Task 1) to research the specific requirements and formats of the second target platform
7. Use GPT4 (Task 1) to generate an optimized search query for the second platform based on the user preferences and platform requirements
8. Use GPT4 (Task 1) to research the specific requirements and formats of the third target platform
9. Use GPT4 (Task 1) to generate an optimized search query for the third platform based on the user preferences and platform requirements
10. Use GPT4 (Task 1) to research the specific requirements and formats of the fourth target platform
11. Use GPT4 (Task 1) to generate an optimized search query for the fourth platform based on the user preferences and platform requirements
12. Use GPT4 (Task 1) to research the specific requirements and formats of the fifth target platform
13. Use GPT4 (Task 1) to generate an optimized search query for the fifth platform based on the user preferences and platform requirements
14. Structure the generated search queries into a JSON format
15. Save the JSON file containing the generated search queries using Save content to server (Task 9)

Note: The number of repetitions for researching platform requirements and generating search queries (steps 4-13) may vary depending on the number of target music/sample websites and APIs identified in step 3.

Subagent1 task-ID-numbers

subagent1-output-variables

Here's the updated task list with output tokens:

G) FULL TASKS (INCLUDING REPEATING TASKS):

1. Receive structured user preferences in JSON format [user-preferences]
2. Use GPT4 (Task 1) to analyze user preferences and generate a list of relevant keywords and phrases [keywords-phrases]
3. Research and compile a list of target music/sample websites and APIs [target-platforms]
4. Use GPT4 (Task 1) to research the specific requirements and formats of the first target platform [platform1-requirements]
5. Use GPT4 (Task 1) to generate an optimized search query for the first platform based on the user preferences and platform requirements [platform1-search-query]
6. Use GPT4 (Task 1) to research the specific requirements and formats of the second target platform [platform2-requirements]
7. Use GPT4 (Task 1) to generate an optimized search query for the second platform based on the user preferences and platform requirements [platform2-search-query]
8. Use GPT4 (Task 1) to research the specific requirements and formats of the third target platform [platform3-requirements]
9. Use GPT4 (Task 1) to generate an optimized search query for the third platform based on the user preferences and platform requirements [platform3-search-query]
10. Use GPT4 (Task 1) to research the specific requirements and formats of the fourth target platform [platform4-requirements]
11. Use GPT4 (Task 1) to generate an optimized search query for the fourth platform based on the user preferences and platform requirements [platform4-search-query]
12. Use GPT4 (Task 1) to research the specific requirements and formats of the fifth target platform [platform5-requirements]
13. Use GPT4 (Task 1) to generate an optimized search query for the fifth platform based on the user preferences and platform requirements [platform5-search-query]
14. Structure the generated search queries into a JSON format [search-queries-json]
15. Save the JSON file containing the generated search queries using Save content to server (Task 9) [saved-search-queries]

H) OUTPUT TOKENS:

[user-preferences]
[keywords-phrases]
[target-platforms]
[platform1-requirements]
[platform1-search-query]
[platform2-requirements]
[platform2-search-query]
[platform3-requirements]
[platform3-search-query]
[platform4-requirements]
[platform4-search-query]
[platform5-requirements]
[platform5-search-query]
[search-queries-json]
[saved-search-queries]

subagent1refined-repeating-json-core

A) SUBAGENT SUMMARY: Generate optimized search queries for multiple music/sample platforms based on user preferences.

B) FINAL TASK OUTPUT: A JSON file containing structured search queries optimized for each target music/sample platform, considering user preferences and platform-specific requirements.

C) SUBAGENT INPUT:
- Structured user preferences in JSON format, including key, tempo, style, previous artists who sampled it, desired instrumentation, etc.

E) SUBAGENT TASK SUMMARY:
1. Analyze user preferences using GPT4 to generate relevant keywords and phrases
2. Research and compile a list of target music/sample websites and APIs
3. For each target platform:
   a. Research the specific requirements and formats using GPT4
   b. Generate an optimized search query based on user preferences and platform requirements using GPT4
4. Structure the generated search queries into a JSON format
5. Save the JSON file containing the search queries

F) SILOS: None

G) TASKFLOW SUMMARY:

Task 1:
Title task: Analyze user preferences
Description of the task: Use GPT4 to analyze the structured user preferences in JSON format and generate a list of relevant keywords and phrases for searching music/sample platforms.
Input(s) involved: [structured_user_preferences]
Output token name: [relevant_keywords_and_phrases]

Task 2:
Title task: Compile target platforms
Description of the task: Research and compile a list of target music/sample websites and APIs to search for samples based on user preferences.
Input(s) involved: None
Output token name: [target_platforms]

Task 3:
Title task: Research platform requirements
Description of the task: Use GPT4 to research the specific requirements and formats of each target music/sample platform identified in the previous task.
Input(s) involved: [target_platforms]
Output token name: [platform_requirements]

Task 4:
Title task: Generate optimized search queries
Description of the task: Use GPT4 to generate an optimized search query for each target platform based on the user preferences and platform-specific requirements.
Input(s) involved: [relevant_keywords_and_phrases], [platform_requirements]
Output token name: [optimized_search_queries]

Task 5:
Title task: Structure search queries
Description of the task: Structure the generated search queries into a JSON format for easy storage and retrieval.
Input(s) involved: [optimized_search_queries]
Output token name: [structured_search_queries]

Task 6:
Title task: Save search queries
Description of the task: Save the JSON file containing the structured search queries using the "Save content to server" task.
Input(s) involved: [structured_search_queries]
Output token name: None

subagent1mermaid

SubAgent #2

claude 3 - subagent2

subagent2-refined

A) SUBAGENT SUMMARY: The Music Website Scraper subagent uses search queries to scrape song data from multiple websites and stores the scraped data on the server.

B) FINAL TASK OUTPUT: A JSON file containing an array of objects, where each object represents a song with the following properties:
- title (string): The title of the song
- artist (string): The name of the artist
- youtube_link (string): The YouTube URL of the song
- metadata (object): Additional metadata about the song (if available), such as tempo, key, instrumentation, etc.

C) SUBAGENT INPUT:
- A text file containing a list of search queries tailored to different music/sample websites or APIs

D) SUBAGENT TASK SUMMARY:
1. Load search queries from a text file using the "Access text files already saved" task (Task 10).
2. For each search query:
   a. Use the "Search Google" task (Task 15) to find relevant music/sample websites.
   b. Extract the top 3 website URLs from the Google search results using the "GPT4" task (Task 1).
   c. For each website URL:
      i. Use the "Scrape text content of website" task (Task 16) to extract song data (title, artist, metadata) from the website.
      ii. Use the "Scrape links from website" task (Task 17) to extract YouTube links for the songs.
      iii. Combine the scraped song data and YouTube links into a JSON object using the "GPT4" task (Task 1).
      iv. Append the JSON object to an array.
   d. Save the array of JSON objects to a text file using the "Save content to server" task (Task 9).
3. Combine all the saved text files into a single JSON file using the "Concatenate text/html files" task (Task 13).
4. Save the final JSON file using the "Save content to server" task (Task 9).

E) SILOS:
Silo 1: Search Query Processing
- Load search queries (Task 10)
- Search Google for each query (Task 15)
- Extract top 3 website URLs (Task 1)

Silo 2: Website Scraping
- Scrape song data from each website (Task 16)
- Scrape YouTube links from each website (Task 17)
- Combine scraped data into JSON objects (Task 1)
- Save JSON objects to text files (Task 9)

Silo 3: Data Aggregation
- Concatenate all saved text files into a single JSON file (Task 13)
- Save the final JSON file (Task 9)

subagent2refined-repeating

G) FULL TASKS (INCLUDING REPEATING TASKS):

1. Access text files already saved (Task 10)
   - Load search queries from a text file
2. Search Google (Task 15)
   - Search Google for the first query
3. GPT4 (Task 1)
   - Extract the top 3 website URLs from the Google search results for the first query
4. Scrape text content of website (Task 16)
   - Scrape song data (title, artist, metadata) from the first website URL for the first query
5. Scrape links from website (Task 17)
   - Scrape YouTube links for the songs from the first website URL for the first query
6. GPT4 (Task 1)
   - Combine the scraped song data and YouTube links into a JSON object for the first website URL for the first query
7. Scrape text content of website (Task 16)
   - Scrape song data (title, artist, metadata) from the second website URL for the first query
8. Scrape links from website (Task 17)
   - Scrape YouTube links for the songs from the second website URL for the first query
9. GPT4 (Task 1)
   - Combine the scraped song data and YouTube links into a JSON object for the second website URL for the first query
10. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the third website URL for the first query
11. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the third website URL for the first query
12. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the third website URL for the first query
13. Save content to server (Task 9)
    - Save the array of JSON objects for the first query to a text file
14. Search Google (Task 15)
    - Search Google for the second query
15. GPT4 (Task 1)
    - Extract the top 3 website URLs from the Google search results for the second query
16. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the first website URL for the second query
17. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the first website URL for the second query
18. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the first website URL for the second query
19. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the second website URL for the second query
20. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the second website URL for the second query
21. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the second website URL for the second query
22. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the third website URL for the second query
23. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the third website URL for the second query
24. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the third website URL for the second query
25. Save content to server (Task 9)
    - Save the array of JSON objects for the second query to a text file
26. Repeat steps 14-25 for each remaining search query in the text file
27. Concatenate text/html files (Task 13)
    - Combine all the saved text files into a single JSON file
28. Save content to server (Task 9)
    - Save the final JSON file

Subagent2 task-ID-numbers

subagent2-output-variables

Here's the updated task list with output tokens added in the new "H) OUTPUT TOKENS" section:

H) OUTPUT TOKENS

1. Access text files already saved (Task 10)
   - Load search queries from a text file
   - Output: [search-queries]
2. Search Google (Task 15)
   - Search Google for the first query
   - Output: [search-results-query1]
3. GPT4 (Task 1)
   - Extract the top 3 website URLs from the Google search results for the first query
   - Output: [urls-query1]
4. Scrape text content of website (Task 16)
   - Scrape song data (title, artist, metadata) from the first website URL for the first query
   - Output: [song-data-query1-url1]
5. Scrape links from website (Task 17)
   - Scrape YouTube links for the songs from the first website URL for the first query
   - Output: [youtube-links-query1-url1]
6. GPT4 (Task 1)
   - Combine the scraped song data and YouTube links into a JSON object for the first website URL for the first query
   - Output: [json-query1-url1]
7. Scrape text content of website (Task 16)
   - Scrape song data (title, artist, metadata) from the second website URL for the first query
   - Output: [song-data-query1-url2]
8. Scrape links from website (Task 17)
   - Scrape YouTube links for the songs from the second website URL for the first query
   - Output: [youtube-links-query1-url2]
9. GPT4 (Task 1)
   - Combine the scraped song data and YouTube links into a JSON object for the second website URL for the first query
   - Output: [json-query1-url2]
10. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the third website URL for the first query
    - Output: [song-data-query1-url3]
11. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the third website URL for the first query
    - Output: [youtube-links-query1-url3]
12. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the third website URL for the first query
    - Output: [json-query1-url3]
13. Save content to server (Task 9)
    - Save the array of JSON objects for the first query to a text file
    - Output: [saved-json-query1]
14. Search Google (Task 15)
    - Search Google for the second query
    - Output: [search-results-query2]
15. GPT4 (Task 1)
    - Extract the top 3 website URLs from the Google search results for the second query
    - Output: [urls-query2]
16. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the first website URL for the second query
    - Output: [song-data-query2-url1]
17. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the first website URL for the second query
    - Output: [youtube-links-query2-url1]
18. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the first website URL for the second query
    - Output: [json-query2-url1]
19. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the second website URL for the second query
    - Output: [song-data-query2-url2]
20. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the second website URL for the second query
    - Output: [youtube-links-query2-url2]
21. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the second website URL for the second query
    - Output: [json-query2-url2]
22. Scrape text content of website (Task 16)
    - Scrape song data (title, artist, metadata) from the third website URL for the second query
    - Output: [song-data-query2-url3]
23. Scrape links from website (Task 17)
    - Scrape YouTube links for the songs from the third website URL for the second query
    - Output: [youtube-links-query2-url3]
24. GPT4 (Task 1)
    - Combine the scraped song data and YouTube links into a JSON object for the third website URL for the second query
    - Output: [json-query2-url3]
25. Save content to server (Task 9)
    - Save the array of JSON objects for the second query to a text file
    - Output: [saved-json-query2]
26. Repeat steps 14-25 for each remaining search query in the text file
    - Output: [saved-json-query1], [saved-json-query2], ... , [saved-json-queryN]
27. Concatenate text/html files (Task 13)
    - Combine all the saved text files into a single JSON file
    - Output: [combined-json]
28. Save content to server (Task 9)
    - Save the final JSON file
    - Output: [saved-final-json]

subagent2refined-repeating-json-core

A) SUBAGENT SUMMARY: Subagent to scrape song data and YouTube links from websites based on search queries and save the results as JSON files.

B) FINAL TASK OUTPUT: A single JSON file containing arrays of JSON objects for each search query. Each JSON object includes song data (title, artist, metadata) and corresponding YouTube links scraped from the top 3 websites for each query.

C) SUBAGENT INPUT:
- A text file containing search queries (one query per line)

E) SUBAGENT TASK SUMMARY:
1. Load search queries from a text file
2. For each search query:
   a. Search Google for the query
   b. Extract the top 3 website URLs from the search results
   c. For each website URL:
      i. Scrape song data (title, artist, metadata) from the website
      ii. Scrape YouTube links for the songs from the website
      iii. Combine the scraped song data and YouTube links into a JSON object
   d. Save the array of JSON objects for the query to a text file
3. Combine all the saved text files into a single JSON file
4. Save the final JSON file

F) SILOS: (none)

G) TASKFLOW SUMMARY:

Task 1
Title task: Load search queries
Description of the task: Read a text file containing search queries, with one query per line, and store them in a list for further processing.
Input(s) involved: [search_queries_file]
Output token name: [search_queries_list]

Task 2
Title task: Search Google
Description of the task: Perform a Google search for a given query and return the search results page as HTML.
Input(s) involved: [search_query]
Output token name: [search_results_html]

Task 3
Title task: Extract top website URLs
Description of the task: Parse the Google search results HTML and extract the top 3 website URLs.
Input(s) involved: [search_results_html]
Output token name: [top_website_urls]

Task 4
Title task: Scrape song data
Description of the task: Visit a website URL and scrape song data (title, artist, metadata) from the page.
Input(s) involved: [website_url]
Output token name: [scraped_song_data]

Task 5
Title task: Scrape YouTube links
Description of the task: Visit a website URL and scrape YouTube links for the songs from the page.
Input(s) involved: [website_url]
Output token name: [scraped_youtube_links]

Task 6
Title task: Create JSON object
Description of the task: Combine the scraped song data and YouTube links into a JSON object for a single website.
Input(s) involved: [scraped_song_data], [scraped_youtube_links]
Output token name: [website_json_object]

Task 7
Title task: Save JSON objects to file
Description of the task: Save the array of JSON objects for a single search query to a text file.
Input(s) involved: [website_json_objects]
Output token name: [query_results_file]

Task 8
Title task: Combine results files
Description of the task: Concatenate all the saved text files containing JSON objects for each search query into a single JSON file.
Input(s) involved: [query_results_files]
Output token name: [combined_json_file]

Task 9
Title task: Save final JSON file
Description of the task: Save the final combined JSON file containing results for all search queries.
Input(s) involved: [combined_json_file]
Output token name: [final_output_file]

subagent2mermaid

SubAgent #3

claude 3 - subagent3

subagent1-refined

A) SUBAGENT SUMMARY: The YouTube Link Extractor subagent will extract YouTube links for the songs obtained from the Music Website Scraper.

B) FINAL TASK OUTPUT: A text file containing a list of YouTube video links (URLs) for the scraped songs, with each link on a separate line.

C) SUBAGENT INPUT:
- A text file containing the scraped song data (title, artist) from the Music Website Scraper subagent.

E) SUBAGENT TASK SUMMARY:
1. Load the scraped song data text file using the "Access text files already saved" task (Task 10).
2. For each song in the scraped data:
   a. Construct a search query using the song title and artist name.
   b. Use the "Search Google" task (Task 15) to search for the song on YouTube.
   c. Extract the YouTube video link from the search results using GPT4 (Task 1).
   d. Append the extracted YouTube link to a list.
3. Use GPT4 (Task 1) to format the list of YouTube links into a plain text file, with each link on a separate line.
4. Save the formatted text file containing the YouTube links using the "Save content to server" task (Task 9).

F) SILOS:
Silo 1: Song Data Loading
- Load the scraped song data text file using the "Access text files already saved" task (Task 10).

Silo 2: YouTube Link Extraction (Repeat for each song)
- Construct a search query using the song title and artist name.
- Use the "Search Google" task (Task 15) to search for the song on YouTube.
- Extract the YouTube video link from the search results using GPT4 (Task 1).
- Append the extracted YouTube link to a list.

Silo 3: Output Generation
- Use GPT4 (Task 1) to format the list of YouTube links into a plain text file, with each link on a separate line.
- Save the formatted text file containing the YouTube links using the "Save content to server" task (Task 9).

subagent1refined-repeating

Subagent1 task-ID-numbers3

subagent3-output-variables

Here's the updated task list with the output tokens added:

G) FULL TASKS (INCLUDING REPEATING TASKS):

1. Access text files already saved (Task 10)
   - Load the scraped song data text file [scraped-song-data]
2. Repeat the following steps for each song in the scraped data:
   a. Use GPT4 (Task 1) to construct a search query using the song title and artist name [search-query-song{i}]
   b. Search Google (Task 15) for the song on YouTube using the constructed search query [search-results-song{i}]
   c. Use GPT4 (Task 1) to extract the YouTube video link from the search results [youtube-link-song{i}]
   d. Use GPT4 (Task 1) to append the extracted YouTube link to a list [youtube-link-list]
3. Use GPT4 (Task 1) to format the list of YouTube links into a plain text file, with each link on a separate line [formatted-youtube-link-list]
4. Save content to server (Task 9)
   - Save the formatted text file containing the YouTube links [saved-youtube-link-file]

H) OUTPUT TOKENS

[scraped-song-data]: The text file containing the scraped song data loaded from the server.
[search-query-song{i}]: The search query constructed for each song using the song title and artist name, where {i} represents the song number (e.g., [search-query-song1], [search-query-song2], etc.).
[search-results-song{i}]: The Google search results for each song on YouTube, where {i} represents the song number (e.g., [search-results-song1], [search-results-song2], etc.).
[youtube-link-song{i}]: The extracted YouTube video link for each song, where {i} represents the song number (e.g., [youtube-link-song1], [youtube-link-song2], etc.).
[youtube-link-list]: The list of extracted YouTube links for all songs.
[formatted-youtube-link-list]: The formatted plain text file containing the list of YouTube links, with each link on a separate line.
[saved-youtube-link-file]: The saved text file containing the formatted list of YouTube links on the server.

subagent3refined-repeating-json-core

G) TASKFLOW SUMMARY

Title task: Load scraped song data
Description of the task: Access and load the previously scraped song data text file containing song titles and artist names.
Input(s) involved: [Scraped song data text file]
Output token name: [Loaded song data]

Title task: Construct search query
Description of the task: Use GPT-4 to generate a search query for each song using the song title and artist name, optimized for finding the song on YouTube.
Input(s) involved: [Loaded song data], [GPT-4 API]
Output token name: [Constructed search query]

Title task: Search YouTube for song
Description of the task: Perform a Google search for each song on YouTube using the constructed search query.
Input(s) involved: [Constructed search query], [Google Search API]
Output token name: [YouTube search results]

Title task: Extract YouTube video link
Description of the task: Utilize GPT-4 to locate and extract the relevant YouTube video link from the search results for each song.
Input(s) involved: [YouTube search results], [GPT-4 API]
Output token name: [Extracted YouTube link]

Title task: Append YouTube link to list
Description of the task: Use GPT-4 to append each extracted YouTube link to a list, maintaining the order of the songs from the original data.
Input(s) involved: [Extracted YouTube link], [GPT-4 API]
Output token name: [List of YouTube links]

Title task: Format YouTube links
Description of the task: Employ GPT-4 to format the list of YouTube links into a plain text file, with each link on a separate line for easy access and readability.
Input(s) involved: [List of YouTube links], [GPT-4 API]
Output token name: [Formatted YouTube links text file]

Title task: Save YouTube links file
Description of the task: Save the formatted text file containing the YouTube links to the server for future reference and use.
Input(s) involved: [Formatted YouTube links text file], [Server API]
Output token name: [Saved YouTube links file]

subagent3mermaid

prompts-required

Based on the list of components provided, here are the unique prompts that you may need to write for this agent workflow:

Task: Generate search queries
Output of the task: A list of search queries tailored to various music/sample websites or APIs
Description: Write a prompt that instructs the LLM to generate search queries based on the user's input preferences (key, tempo, style, previous artists who sampled it, desired instrumentation, etc.). The prompt should guide the LLM to create queries that are compatible with the target websites or APIs, incorporating the relevant search parameters and formatting.

Task: Extract information from search results
Output of the task: Extracted song titles, artist names, YouTube links, and other relevant metadata from the search results
Description: Write a prompt that directs the LLM to analyze the search results obtained from the web scraper or API client. The prompt should instruct the LLM to identify and extract the required information, such as song titles, artist names, YouTube links, and any additional metadata (tempo, key, instrumentation) if available. The LLM should be guided to handle various formats and structures of the search results.

Task: Clean and deduplicate data
Output of the task: Cleaned and deduplicated dataset of songs and their corresponding information
Description: Write a prompt that asks the LLM to perform data cleaning and deduplication on the aggregated dataset. The prompt should provide instructions on identifying and removing duplicate entries, standardizing the format of the data (e.g., consistent naming conventions, date formats), and handling missing or inconsistent information. The LLM should be guided to ensure the resulting dataset is coherent and reliable.

Task: Generate output file
Output of the task: A structured output file (text, CSV, or JSON) containing the list of songs and their YouTube links
Description: Write a prompt that instructs the LLM to generate the final output file based on the cleaned and aggregated dataset. The prompt should specify the desired format of the output file (e.g., text, CSV, or JSON) and provide guidelines on how to structure the information (column names, delimiters, file extensions). The LLM should be directed to ensure the output file is well-formatted and follows the specified structure consistently.

Task: Generate error messages and logging information
Output of the task: Relevant error messages and logging information for debugging and monitoring purposes
Description: Write a prompt that guides the LLM to generate appropriate error messages and logging information based on the encountered errors or exceptions during the workflow execution. The prompt should instruct the LLM to provide informative and actionable error messages, including relevant details such as the component where the error occurred, the specific error type, and any available contextual information. Additionally, the prompt should direct the LLM to generate logging statements that capture important milestones, progress, and any other relevant information for debugging and monitoring purposes.

Please note that depending on the specific implementation and the capabilities of the AI agent, some of these prompts might need to be further refined or adapted to fit the particular requirements and constraints of your system.