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

final-output-comps..1

a) The final output of this task would be a list of songs that meet the provided criteria, along with YouTube links for each song. The list could be presented in various formats, such as a spreadsheet (e.g., CSV or Excel file) or a structured text document (e.g., JSON or XML). The essential information for each song would include:

- Song title
- Artist name
- YouTube link
- Additional metadata (e.g., key, tempo, style, instrumentation, original release year)

b) To break down the task into components, the following outputs would be needed:

1. Search criteria:
   - A structured format (e.g., JSON or XML) that contains the user's input for the desired music characteristics, such as key, tempo, style, previous artists who sampled it, and desired instrumentation.

2. Music/sample website and API integration:
   - A list of relevant music/sample websites and APIs to search for songs based on the provided criteria.
   - API client code or webscraping scripts to interact with these websites and APIs, allowing the AI agent to query and retrieve song information.

3. Song metadata extraction:
   - Code to extract relevant metadata from the search results, such as song title, artist name, key, tempo, style, and instrumentation.
   - This may involve parsing HTML, JSON, or XML responses from the websites and APIs.

4. YouTube link retrieval:
   - Code to search for and retrieve the YouTube link for each song in the search results.
   - This could involve using the YouTube API or webscraping techniques to find the most relevant video for each song.

5. Output generation:
   - Code to compile the retrieved song information and YouTube links into a structured format, such as a CSV file or JSON document.
   - The output should be organized and easily readable, with columns or fields for each piece of information (song title, artist name, YouTube link, metadata).

6. Error handling and logging:
   - Code to handle errors that may occur during the search, retrieval, and output generation processes.
   - Logging functionality to record the progress, success, or failure of each component for debugging and monitoring purposes.

By breaking down the task into these specific components, the AI agent can systematically approach the problem and ensure that each necessary piece is developed and integrated to produce the final output: a list of songs with YouTube links and relevant metadata based on the user's provided criteria.

final-output-comps..2

## Understanding the Final Output and Components

### a) Final Output

The final output of your desired workflow would be **a list of song suggestions with corresponding YouTube links** that fit the specific criteria you input regarding the type of music you want to sample. Essentially, it's a curated list of potential samples tailored to your needs.

### b) Components and Outputs

To achieve this final output, several components need to work together:

**1. Input Processing:**

*   **User Interface:** This could be a simple text box or a more complex form where you input your desired criteria for the sample. This could include:
    *   **Genre/Style:** Hip-hop, jazz, classical, etc.
    *   **Key/Tempo:** Specific key signatures or tempo ranges.
    *   **Mood/Feel:** Upbeat, melancholic, energetic, etc.
    *   **Instrumentation:** Presence of specific instruments like piano, drums, strings, etc. 
    *   **Artists/Examples:** Names of artists or specific songs that used similar samples.

**2. Search and Retrieval:**

*   **Music/Sample Databases/APIs:** The AI agent would need access to databases or APIs that contain information about songs and their characteristics. Examples include:
    *   **MusicBrainz:** A vast open-source database with information on artists, releases, and recordings.
    *   **WhoSampled:** A database specifically focused on identifying samples in music.
    *   **Commercial music APIs:** Several APIs offer access to music metadata and analysis. 
*   **Search Algorithms:** The agent would utilize algorithms to search for songs that match the user's criteria within these databases or APIs. This could involve keyword matching, analyzing musical features, and leveraging machine learning models trained on musical data. 
*   **YouTube API:** Once potential samples are identified, the agent would utilize the YouTube API to search for and retrieve corresponding YouTube video links for the songs.

**3. Output Generation:**

*   **List of Songs:** The system would output a list of songs that match the desired criteria, presented in a user-friendly format.
*   **YouTube Links:** Each song title would be accompanied by a direct link to its respective YouTube video, allowing for instant access and listening.

**Additionally, consider:**

*   **Ranking/Relevance:** The output could be ranked based on how well each song matches the user's criteria, potentially using a scoring system.
*   **Filtering Options:** The user might want to refine their search further by filtering based on criteria like release date, popularity, or length. 
*   **Audio Previews:** Integrating short audio previews for each song could further enhance user experience.

**Remember, the specific APIs and databases used will depend on availability, access, and functionality.**

final-output-comps GPT..3

a) The final output of the task would be a document or report that lists the name of the songs, the relevant music artists, and YouTube links for each song that matches the broad description of the type that you want to sample.

b) If we break down this task into components, these are the core elements that might be needed to generate the final output:

1. Input Interpretation: Before the AI can begin its search, it needs to understand the specifics of the request, such as key, tempo, style, previous artists who sampled it, and desired instrumentation. This would involve natural language processing and machine learning techniques to interpret the user's input accurately.

2. Search and Data Retrieval: This part of the task would involve searching various music databases, streaming platforms, and APIs using specified parameters like key, tempo, style etc. This could be done through API calls, web scraping, or other data retrieval methods. The search also needs to consider copyright constraints.

3. Data Processing: Once the data is retrieved, it needs to be processed to identify songs that match the input description. This involves identifying the titles, artists, and links of the potentially suitable songs.

4. Link Collection: Gathering the YouTube link for each song identified in the data processing step.

5. Output Generation: The final component is the generation and formatting of the resulting list of songs, artists and YouTube links. This could be in the form of a CSV file, a JSON file, or some other standardized format that organizes the output information in an easy-to-consume way.

6. Report Generation: Depending on additional requirements, a summarizing report might be needed to highlight certain aspects of the returned list. It may include key information such as number of songs identified, common artists or characteristics in the list, etc.

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

a) The final output of the automated workflow for finding songs to sample based on the provided criteria would be a structured document, such as a JSON file, CSV file, or formatted text document, containing a list of songs that match the specified requirements. Each song entry in the list would include the following information:

- Song title
- Artist name
- Album (if applicable)
- Year of release
- YouTube link to the song
- Additional metadata (e.g., key, tempo, style, instrumentation)

This output would provide a curated selection of songs that align with the desired sampling criteria, along with direct links to listen to each song on YouTube.

b) To generate this final output, the task can be broken down into the following components:

1. User Input Interface:
   - A user interface or structured input format (e.g., JSON, YAML) where the user can specify the desired criteria for the music samples, such as key, tempo, style, previous artists who sampled it, and desired instrumentation.
   - This component would involve natural language processing and machine learning techniques to interpret the user's input accurately.

2. Music/Sample Database and API Integration:
   - A curated list of reliable music/sample websites, databases, and APIs that the AI agent can access to search for songs based on the input criteria.
   - This would include necessary authentication details (e.g., API keys, credentials) and documentation on how to query each source effectively.
   - Examples of databases and APIs could include MusicBrainz, WhoSampled, and various commercial music APIs.

3. Search and Filtering Mechanism:
   - A programmatic way to query the selected music/sample databases and APIs using the input criteria, constructing appropriate search queries, handling pagination, and parsing the returned results.
   - Search algorithms and techniques to identify songs that match the user's criteria, potentially utilizing keyword matching, musical feature analysis, and machine learning models trained on musical data.
   - A filtering mechanism to refine the search results based on the input criteria, ensuring that the songs closely match the user's requirements.

4. Song Information Extraction:
   - A component to extract the necessary song information from the search results, such as song title, artist name, album, year of release, and the corresponding YouTube link.
   - This may involve web scraping techniques, utilizing API response data, or parsing HTML, JSON, or XML responses from the databases and APIs.

5. YouTube Link Retrieval:
   - Integration with the YouTube API or utilization of web scraping techniques to search for and retrieve the most relevant YouTube video link for each song in the search results.

6. Output Generation:
   - A mechanism to compile the extracted song information and YouTube links into a structured format, such as a JSON file, CSV file, or formatted text document.
   - The output should be organized and easily readable, with columns or fields for each piece of information (song title, artist name, YouTube link, metadata).

7. Error Handling and Logging:
   - Appropriate error handling mechanisms to gracefully handle scenarios such as API rate limits, network failures, invalid search results, or copyright constraints.
   - Logging functionality to keep track of the workflow's progress, any encountered errors, and the final output for debugging and auditing purposes.

By integrating these components into a cohesive workflow, the AI agent can systematically search for songs based on the provided criteria, extract relevant information, retrieve YouTube links, and generate a structured output that meets the user's requirements for sampling purposes. The output can be further enhanced with ranking, filtering options, audio previews, and summary reports to improve the user experience and facilitate the sampling process.

claude 3 - extract final output

extract component outputs

To generate this final output, the task can be broken down into the following components:

Claude - research-ideas-and-input-variables

Thank you for the detailed request. Let me address your questions one by one:

a) To clarify the final output of the task, I would ask the following questions:
- How many song suggestions do you want the AI agent to return?
- Should the song suggestions be presented in a specific format (e.g., a spreadsheet, a text document, or a playlist)?
- Do you need any additional information about each song, such as the artist, year of release, genre, or BPM?
- Should the AI agent prioritize certain factors (e.g., key, tempo, style) when searching for song suggestions?

b) Before launching the task completion process, the AI agent should accept the following inputs:
- A description of the desired music style, including key, tempo, genre, and any other relevant characteristics.
- Examples of artists or songs that have a similar sound to what you're looking for.
- The specific instrumentation you want to be featured in the songs (e.g., guitar, piano, drums).
- Any additional preferences or requirements, such as the era of music or the region/country of origin.

c) I have no insights or suggestions as to how we might want to silo and segment any of the core tasks. The task of finding suitable songs for sampling based on user preferences is fairly focused and does not necessarily require segmentation. However, if the AI agent were to create a more comprehensive music recommendation system, it might be beneficial to segment tasks such as:
- Analyzing user preferences and listening history
- Searching for songs based on various criteria (e.g., genre, era, instrumentation)
- Comparing the recommended songs to the user's existing music library
- Generating personalized playlists based on the recommendations

In this case, since the task is specifically focused on finding songs for sampling purposes based on user input, segmentation may not be necessary.

GPT - research-ideas-and-input-variables

a) To clarify the final output of the task, the following questions can be asked:
1. How many songs or samples do you want to get for each execution of the task?
2. Do you want the AI to differentiate between free and premium content? In other words, are you looking for free samples only or are you open to paying for some?
3. What specific music styles are you interested in? For instance, jazz, classical, pop, rock etc.
4. Are you looking for songs of a specific duration or any duration would be acceptable?
5. Should the list contain only songs that have been sampled by previous artists or should it include any music that fits your input description? 
6. Do you want the AI Agent to prefer more recent music, older music, or doesn't it matter?

b) Before launching the task completion process, the task should accept the following inputs:
1. The type of music to search for.
2. Desired Key of the music.
3. Desired Tempo of the music.
4. The specific style of music preferred.
5. Names of previous artists who sampled similar music, if any.
6. The type of instrumentation wanted in the music.
7. The number of songs desired.  
8. Any preference for the duration of the songs.
9. Free or paid samples preference.
10. Any preference for the age of the music.

template-ideas

Based on the provided information and the task of finding songs to sample, here are some template suggestions that could help refine the definition of a successful output:

1. Music sample pack listings:
   - Visit websites that sell music sample packs and analyze their product descriptions and specifications.
   - Look for details such as the number of samples included, file formats, sample lengths, and any metadata provided.
   - This will give insights into how professional sample packs are structured and presented.

2. Music database or API documentation:
   - Explore the documentation of popular music databases or APIs (e.g., Spotify API, Last.fm API, Discogs API).
   - Look for the data fields and metadata they provide for each song or track.
   - This will help determine the essential information to include in the output, such as song title, artist, album, year, and any additional metadata.

3. Curated playlists or song lists:
   - Search for curated playlists or song lists on music blogs, forums, or websites that focus on a specific genre or style.
   - Analyze the format and structure of these lists, including the information provided for each song.
   - This will provide examples of how music enthusiasts and experts present song recommendations and the key details they include.

4. Music production or sampling tutorials:
   - Look for tutorials or guides on music production or sampling techniques.
   - Pay attention to how they describe the characteristics of good samples, such as key, tempo, style, and instrumentation.
   - This will help identify the important criteria to consider when searching for songs to sample.

5. Music streaming platform search results:
   - Perform searches on music streaming platforms (e.g., Spotify, Apple Music, YouTube Music) using relevant keywords and filters.
   - Analyze the search results page and the information displayed for each song, such as title, artist, album, and any visual elements like album artwork.
   - This will provide insights into how music platforms present song information and what users typically see when searching for music.

6. JSON or CSV files of music datasets:
   - Look for publicly available music datasets in JSON or CSV format.
   - Examine the structure and fields included in these datasets to understand common data formats and the information typically included.
   - This will help define the structure and fields for the output file.

By collecting and analyzing these templates, you can gain a clearer understanding of what a successful output should look like for your song sampling task. Pay attention to the common elements, data fields, and presentation styles across these templates to refine your definition of a successful output.

claude 3 - searches

Based on the provided suggestions and guidelines, here are 5 specific Google search keyphrases to help refine the definition of a successful output for the song sampling task:

1. "royalty free hip hop sample pack wav files tempo key bpm"
   This search will help find music sample pack listings that include relevant metadata such as tempo, key, and BPM, specifically for hip hop samples in WAV format.

2. "spotify api track object json example"
   This search will return examples of JSON responses from the Spotify API, showcasing the structure and fields provided for each track, including song title, artist, album, and additional metadata.

3. "best songs to sample for lo-fi beats reddit"
   This search will uncover curated lists or discussions on Reddit about the best songs to sample for creating lo-fi beats, providing insights into the format and information included in such recommendations.

4. "how to find samples for drill beats youtube tutorial"
   This search will surface tutorials or guides on YouTube that explain the process of finding suitable samples for creating drill beats, highlighting the important characteristics and criteria to consider when selecting songs to sample.

5. "sample based music dataset github csv"
   This search will help discover publicly available music datasets on GitHub that are specifically focused on sample-based music, allowing you to examine the structure and fields included in these datasets and understand common data formats.

By running these specific Google searches and reviewing the top results, you should be able to find helpful templates and examples that will refine your understanding of what a successful output should look like for the song sampling task.

Royalty Free Hip Hop Sample Pack WAV Files with Tempo, Key, and BPM
Spotify API Track Object JSON Example
Best Songs to Sample for Lo-Fi Beats on Reddit
How to Find Samples for Drill Beats YouTube Tutorial
Sample Based Music Dataset on GitHub in CSV Format

subagent-summary

A) FULL TASK SUMMARY: Create an automated workflow to find songs for sampling based on user-specified criteria and generate a structured output with song information and YouTube links.

B) FINAL TASK OUTPUT: A JSON file containing a list of songs that match the user's sampling criteria, with each song entry including the song title, artist name, album (if applicable), year of release, YouTube link, and additional metadata such as key, tempo, style, and instrumentation.

C) COMPONENTS OVERVIEW:
1. User Input Interface
2. Music/Sample Database and API Integration
3. Search and Filtering Mechanism
4. Song Information Extraction
5. YouTube Link Retrieval
6. Output Generation
7. Error Handling and Logging

D) OVERVIEW OF SUBAGENTS:
- User Input Parser: Interprets and validates user input, converting it into a structured format for further processing.
- Music Database Connector: Establishes connections to various music databases and APIs, handling authentication and query formatting.
- Music Sampler: Searches and filters songs based on the user's criteria, utilizing the Music Database Connector.
- Song Info Extractor: Extracts relevant song information from the search results obtained by the Music Sampler.
- YouTube Link Finder: Retrieves the most relevant YouTube link for each song identified by the Song Info Extractor.
- Output Generator: Compiles the extracted song information and YouTube links into a structured JSON file.
- Error Handler: Manages error scenarios and logs workflow progress and issues.

E) SUBAGENT 1: User Input Parser
- Name: User Input Parser
- Final Output: Structured input data (e.g., JSON) containing the user's sampling criteria
- Accomplishment: The User Input Parser will provide a user-friendly interface (e.g., web form, command-line interface) where users can enter their sampling criteria in natural language. It will utilize natural language processing techniques to interpret and validate the input, extracting key information such as tempo, style, instrumentation, and previous artists. The parsed input will be converted into a structured format (e.g., JSON) for further processing.
- Sequence: Receive user input > Parse and validate input using NLP > Extract key information > Convert to structured format > Output structured input data

F) SUBAGENT 2: Music Database Connector
- Name: Music Database Connector
- Final Output: Authenticated connections to music databases and APIs, ready for querying
- Accomplishment: The Music Database Connector will establish connections to various music databases and APIs specified in the workflow configuration. It will handle authentication by managing API keys, tokens, or credentials securely. The subagent will also format queries based on the specific requirements of each database or API, ensuring compatibility and optimal results.
- Sequence: Read database/API configuration > Establish connections > Authenticate with each database/API > Format query templates > Output authenticated connections

G) SUBAGENT 3: Music Sampler
- Name: Music Sampler
- Final Output: List of songs that match the user's sampling criteria
- Accomplishment: The Music Sampler will utilize the authenticated connections provided by the Music Database Connector to search for songs based on the user's criteria. It will construct appropriate search queries using the structured input data from the User Input Parser. The subagent will handle pagination and parse the search results, applying filtering mechanisms to refine the results based on the criteria. It will leverage search algorithms and machine learning models to identify the most relevant songs.
- Sequence: Receive structured input data and authenticated connections > Construct search queries > Execute queries on databases/APIs > Handle pagination and parse results > Apply filtering and ranking algorithms > Output list of matching songs

H) SUBAGENT 4: Song Info Extractor
- Name: Song Info Extractor
- Final Output: Extracted song information (title, artist, album, year, metadata) for each matching song
- Accomplishment: The Song Info Extractor will process the list of matching songs provided by the Music Sampler. It will extract relevant song information such as the song title, artist name, album (if available), year of release, and additional metadata from the search results. The subagent will utilize web scraping techniques, API response parsing, or data extraction libraries to obtain the required information accurately.
- Sequence: Receive list of matching songs > Iterate over each song > Extract song information using web scraping or API parsing > Store extracted information > Output extracted song information

I) SUBAGENT 5: YouTube Link Finder
- Name: YouTube Link Finder
- Final Output: YouTube link for each matching song
- Accomplishment: The YouTube Link Finder will take the list of matching songs and their extracted information from the Song Info Extractor. It will utilize the YouTube API or web scraping techniques to search for the most relevant YouTube video link for each song. The subagent will handle scenarios where multiple video results are found and select the most appropriate one based on relevance and quality.
- Sequence: Receive list of matching songs and extracted information > Iterate over each song > Search for song on YouTube using API or web scraping > Select most relevant video link > Store YouTube link > Output YouTube links for each song

J) SUBAGENT 6: Output Generator
- Name: Output Generator
- Final Output: Structured JSON file containing song information and YouTube links
- Accomplishment: The Output Generator will receive the extracted song information and YouTube links from the Song Info Extractor and YouTube Link Finder. It will compile this data into a structured JSON file, organizing the information into a readable and easily parsable format. The subagent will handle the creation of the JSON structure, ensuring proper formatting and escaping of special characters.
- Sequence: Receive extracted song information and YouTube links > Create JSON structure > Populate JSON with song information and YouTube links > Format and escape JSON data > Save JSON file > Output final JSON file

K) SUBAGENT 7: Error Handler
- Name: Error Handler
- Final Output: Error logs and graceful handling of workflow issues
- Accomplishment: The Error Handler will monitor the execution of the entire workflow, capturing any errors or exceptions that occur during the process. It will implement error handling mechanisms to gracefully handle scenarios such as API rate limits, network failures, invalid search results, or copyright constraints. The subagent will log the progress of the workflow, including any encountered errors, for debugging and auditing purposes.
- Sequence: Monitor workflow execution > Capture errors and exceptions > Handle errors gracefully > Log workflow progress and issues > Provide error reports and notifications > Ensure smooth workflow execution

These subagents, working together, will create an automated workflow that takes user input, searches music databases and APIs, extracts song information, retrieves YouTube links, and generates a structured JSON output containing songs suitable for sampling based on the user's criteria. The Error Handler ensures the workflow runs smoothly, handling any issues that may arise during the process.

subagent-summary-amended-for-actual-tasks..1

Here is the updated list of subagents and their associated tasks based on the available actions:

A) FULL TASK SUMMARY: Create an automated workflow to find songs for sampling based on user-specified criteria and generate a structured output with song information and YouTube links.

C) COMPONENTS OVERVIEW:
1. Music/Sample Database and API Integration
2. Search and Filtering Mechanism
3. Song Information Extraction
4. YouTube Link Retrieval
5. Output Generation
6. Error Handling and Logging

D) OVERVIEW OF SUBAGENTS:
- Music Database Connector: Establishes connections to various music databases and APIs, handling authentication and query formatting.
- Music Sampler: Searches and filters songs based on the user's criteria, utilizing the Music Database Connector.
- Song Info Extractor: Extracts relevant song information from the search results obtained by the Music Sampler.
- YouTube Link Finder: Retrieves the most relevant YouTube link for each song identified by the Song Info Extractor.
- Output Generator: Compiles the extracted song information and YouTube links into a structured JSON file.
- Error Handler: Manages error scenarios and logs workflow progress and issues.

E) SUBAGENT 1: Music Database Connector
- Name: Music Database Connector
- Final Output: Authenticated connections to music databases and APIs, ready for querying
- Tasks:
  - GPT4 (Task 1): Read database/API configuration and format query templates
  - REQUIRED: Establish connections and authenticate with each database/API
- Sequence: Read database/API configuration > Format query templates using GPT4 > Establish connections and authenticate (REQUIRED) > Output authenticated connections

F) SUBAGENT 2: Music Sampler
- Name: Music Sampler
- Final Output: List of songs that match the user's sampling criteria
- Tasks:
  - GPT4 (Task 1): Construct search queries based on user's criteria
  - REQUIRED: Execute queries on databases/APIs, handle pagination, and parse results
  - GPT4 (Task 1): Apply filtering and ranking algorithms to refine search results
- Sequence: Receive structured input data and authenticated connections > Construct search queries using GPT4 > Execute queries on databases/APIs (REQUIRED) > Handle pagination and parse results (REQUIRED) > Apply filtering and ranking algorithms using GPT4 > Output list of matching songs

G) SUBAGENT 3: Song Info Extractor
- Name: Song Info Extractor
- Final Output: Extracted song information (title, artist, album, year, metadata) for each matching song
- Tasks:
  - REQUIRED: Extract song information from search results using API response parsing or data extraction libraries
  - GPT4 (Task 1): Process and organize extracted song information
- Sequence: Receive list of matching songs > Extract song information using API parsing or data extraction libraries (REQUIRED) > Process and organize extracted information using GPT4 > Output extracted song information

H) SUBAGENT 4: YouTube Link Finder
- Name: YouTube Link Finder
- Final Output: YouTube link for each matching song
- Tasks:
  - Search Google (Task 15): Search for each song on YouTube
  - GPT4 (Task 1): Select the most relevant video link from search results
- Sequence: Receive list of matching songs and extracted information > Search for each song on YouTube using Google Search (Task 15) > Select most relevant video link using GPT4 > Store YouTube link > Output YouTube links for each song

I) SUBAGENT 5: Output Generator
- Name: Output Generator
- Final Output: Structured JSON file containing song information and YouTube links
- Tasks:
  - GPT4 (Task 1): Create JSON structure and populate with song information and YouTube links
  - Save content to server (Task 9): Save JSON file to server
- Sequence: Receive extracted song information and YouTube links > Create JSON structure and populate using GPT4 > Format and escape JSON data using GPT4 > Save JSON file to server (Task 9) > Output final JSON file URL

J) SUBAGENT 6: Error Handler
- Name: Error Handler
- Final Output: Error logs and graceful handling of workflow issues
- Tasks:
  - REQUIRED: Monitor workflow execution and capture errors and exceptions
  - GPT4 (Task 1): Generate error reports and notifications
  - Save content to server (Task 9): Save error logs to server
- Sequence: Monitor workflow execution (REQUIRED) > Capture errors and exceptions (REQUIRED) > Handle errors gracefully using GPT4 > Generate error reports and notifications using GPT4 > Save error logs to server (Task 9) > Ensure smooth workflow execution

These subagents, utilizing the available tasks and some required API calls or libraries, will work together to create an automated workflow that takes user input, searches music databases and APIs, extracts song information, retrieves YouTube links, and generates a structured JSON output containing songs suitable for sampling based on the user's criteria. The Error Handler ensures the workflow runs smoothly, handling any issues that may arise during the process.

subagent-summary-amended-for-actual-tasks..2

A) FULL TASK SUMMARY: Create an automated workflow to find songs for sampling based on user-specified criteria and generate a structured output with song information and YouTube links.

C) COMPONENTS OVERVIEW:
1. Search and Filtering Mechanism
2. Song Information Extraction
3. YouTube Link Retrieval
4. Output Generation
5. Error Handling and Logging

D) OVERVIEW OF SUBAGENTS:
- Music Sampler: Searches for songs based on the user's criteria using APIs and web scraping.
- Song Info Extractor: Extracts relevant song information from the search results obtained by the Music Sampler.
- YouTube Link Finder: Retrieves the most relevant YouTube link for each song identified by the Song Info Extractor.
- Output Generator: Compiles the extracted song information and YouTube links into a structured JSON file.
- Error Handler: Manages error scenarios and logs workflow progress and issues.

E) SUBAGENT 1: Music Sampler
- Name: Music Sampler
- Final Output: List of songs that match the user's sampling criteria
- Accomplishment: The Music Sampler will utilize the user's input criteria to search for relevant songs using APIs and web scraping techniques. It will construct appropriate search queries based on the provided criteria, such as key, tempo, style, instrumentation, and previous artists who sampled the music. The subagent will handle pagination and parse the search results to identify the most relevant songs.
- Sequence:
  1. Use GPT4 (Task 1) to interpret the user's input criteria and generate search queries.
  2. Perform web searches using Search Google (Task 15) to find relevant music databases and APIs.
  3. Scrape text content from the identified websites using Scrape text content of website (Task 16) to gather song information.
  4. Use GPT4 (Task 1) to analyze the scraped content and identify relevant songs based on the user's criteria.
  5. Output a list of matching songs.

F) SUBAGENT 2: Song Info Extractor
- Name: Song Info Extractor
- Final Output: Extracted song information (title, artist, album, year, metadata) for each matching song
- Accomplishment: The Song Info Extractor will process the list of matching songs provided by the Music Sampler. It will extract relevant song information such as the song title, artist name, album (if available), year of release, and additional metadata from the search results. The subagent will utilize web scraping techniques and data extraction libraries to obtain the required information accurately.
- Sequence:
  1. Receive the list of matching songs from the Music Sampler.
  2. Iterate over each song and scrape the relevant websites using Scrape text content of website (Task 16) to extract song information.
  3. Use GPT4 (Task 1) to analyze the scraped content and extract the required song details.
  4. Store the extracted information for each song.
  5. Output the extracted song information.

G) SUBAGENT 3: YouTube Link Finder
- Name: YouTube Link Finder
- Final Output: YouTube link for each matching song
- Accomplishment: The YouTube Link Finder will take the list of matching songs and their extracted information from the Song Info Extractor. It will utilize the YouTube API or web scraping techniques to search for the most relevant YouTube video link for each song. The subagent will handle scenarios where multiple video results are found and select the most appropriate one based on relevance and quality.
- Sequence:
  1. Receive the list of matching songs and extracted information from the Song Info Extractor.
  2. Iterate over each song and search for the song on YouTube using Search Google (Task 15) with the song title and artist name as keywords.
  3. Scrape the YouTube search results using Scrape links from website (Task 17) to obtain video links.
  4. Use GPT4 (Task 1) to analyze the video titles, descriptions, and durations to select the most relevant video link for each song.
  5. Store the YouTube link for each song.
  6. Output the YouTube links for each song.

H) SUBAGENT 4: Output Generator
- Name: Output Generator
- Final Output: Structured JSON file containing song information and YouTube links
- Accomplishment: The Output Generator will receive the extracted song information and YouTube links from the Song Info Extractor and YouTube Link Finder. It will compile this data into a structured JSON file, organizing the information into a readable and easily parsable format. The subagent will handle the creation of the JSON structure, ensuring proper formatting and escaping of special characters.
- Sequence:
  1. Receive the extracted song information and YouTube links from the Song Info Extractor and YouTube Link Finder.
  2. Use GPT4 (Task 1) to generate the JSON structure and populate it with the song information and YouTube links.
  3. Format and escape the JSON data to ensure compatibility and readability.
  4. Save the JSON file to the server using Save content to server (Task 9).
  5. Output the URL of the final JSON file.

I) SUBAGENT 5: Error Handler
- Name: Error Handler
- Final Output: Error logs and graceful handling of workflow issues
- Accomplishment: The Error Handler will monitor the execution of the entire workflow, capturing any errors or exceptions that occur during the process. It will implement error handling mechanisms to gracefully handle scenarios such as API rate limits, network failures, invalid search results, or missing data. The subagent will log the progress of the workflow, including any encountered errors, for debugging and auditing purposes.
- Sequence:
  1. Monitor the execution of each subagent and task throughout the workflow.
  2. Capture any errors or exceptions that occur during the process.
  3. Use GPT4 (Task 1) to analyze the errors and determine appropriate error handling strategies.
  4. Implement error handling mechanisms, such as retrying failed requests, handling missing data gracefully, or providing default values.
  5. Log the workflow progress, including successful operations and encountered errors, using Save content to server (Task 9) to create log files.
  6. Provide error reports and notifications to the user or administrator if critical issues occur.
  7. Ensure the smooth execution of the workflow by gracefully handling errors and preventing unexpected termination.

These subagents, working together, will create an automated workflow that takes user input, searches for relevant songs based on the specified criteria, extracts song information, retrieves YouTube links, and generates a structured JSON output containing songs suitable for sampling. The Error Handler ensures the workflow runs smoothly, handling any issues that may arise during the process.

subagent-summary-amended-for-actual-tasks GPT..3

Given the provided list of tasks your AI agent can perform, let's reinterpret the subagents needed to fulfill the components of the workflow for finding music samples. Here's how each component can be aligned with the available tasks:

D) OVERVIEW OF SUBAGENTS:

E) COMPONENT 1: User Input Interface
- Subagent: N/A (Covered by the agent's native interface capabilities)

F) COMPONENT 2: Music/Sample Database and API Integration
- Subagent: External Music Database Search Agent
  - Function: Search available musical databases and APIs for songs matching the criteria
  - Required Task: Use a combination of "Search Google" (Task 15) for general searches and possibly "Prompt generator" (Task 2) for creating precise search prompts. A custom API call would be REQUIRED to directly integrate with musical databases like MusicBrainz or WhoSampled.

G) COMPONENT 3: Search and Filtering Mechanism
- Subagent: Search Result Filter Agent
  - Function: Filter the search results to fit specified criteria
  - Required Task: To filter and rank the search results, "GPT4" (Task 1) can be used to process and refine the list by applying logic and criteria set by the initial user input since there's no direct task for filtering existing lists.

H) COMPONENT 4: Song Information Extraction
- Subagent: Song Information Extractor Agent
  - Function: Extract necessary song information (e.g. key, tempo, style, etc.) from the database/API responses.
  - Required Task: Use "Scrape text content of website" (Task 16) to scrape song information from music database web pages. However, an API call would be REQUIRED to directly extract structured song metadata from musical databases or APIs.

I) COMPONENT 5: YouTube Link Retrieval
- Subagent: YouTube Link Acquisition Agent
  - Function: Retrieve YouTube links for each song.
  - Required Task: Use "Search Google" (Task 15) to find YouTube links. Alternatively, a custom API call would be REQUIRED for direct YouTube API integration to find the most relevant videos for the songs.

J) COMPONENT 6: Output Generation
- Subagent: Structured Output Generation Agent
  - Function: Compile the extracted song information and YouTube links into a structured JSON file.
  - Required Task: Use "Save content to server" (Task 9) to compile and format the structured data into a JSON file, and "Move files around server" (Task 8) for final file placement.

K) COMPONENT 7: Error Handling and Logging
- Subagent: Error Handling and Logging Agent
  - Function: Handle errors gracefully and log operations.
  - Required Task: Use "GPT4" (Task 1) to generate error logs based on the output of other tasks. Issue handling protocols would need to be created with "GPT4" (Task 1) and saved with "Save content to server" (Task 9).

Each of the subagents that require specific API integrations will need new capabilities programmed into the agent, as the required direct API integration tasks are not currently listed among the available tasks. These integrations are essential for querying databases like MusicBrainz or WhoSampled and interacting with the YouTube API to retrieve song links. Once these capabilities are programmed and added to the list of available tasks, the agent can then complete the workflow.

subagent-summary-amended-for-actual-tasks

A) FULL TASK SUMMARY: Create an automated workflow to find songs for sampling based on user-specified criteria and generate a structured output with song information and YouTube links.

F) SUBAGENT 2: Music Sampler
- Name: Music Sampler
- Final Output: List of songs that match the user's sampling criteria
- Tasks:
  - GPT4 (Task 1): Interpret user's input criteria and generate search queries
  - Search Google (Task 15): Find relevant music databases and APIs
  - Scrape text content of website (Task 16): Gather song information from identified websites
  - GPT4 (Task 1): Analyze scraped content and identify relevant songs based on user's criteria
  - REQUIRED: Execute queries on databases/APIs, handle pagination, and parse results
  - GPT4 (Task 1): Apply filtering and ranking algorithms to refine search results
- Sequence: Receive structured input data and authenticated connections > Interpret user's criteria and generate search queries using GPT4 > Find relevant databases and APIs using Google Search > Scrape song information from websites > Analyze scraped content and identify relevant songs using GPT4 > Execute queries on databases/APIs (REQUIRED) > Handle pagination and parse results (REQUIRED) > Apply filtering and ranking algorithms using GPT4 > Output list of matching songs

G) SUBAGENT 3: Song Info Extractor
- Name: Song Info Extractor
- Final Output: Extracted song information (title, artist, album, year, metadata) for each matching song
- Tasks:
  - Scrape text content of website (Task 16): Extract song information from search results
  - REQUIRED: Extract structured song metadata from musical databases or APIs
  - GPT4 (Task 1): Process and organize extracted song information
- Sequence: Receive list of matching songs > Extract song information using web scraping (Task 16) and API calls (REQUIRED) > Process and organize extracted information using GPT4 > Output extracted song information

H) SUBAGENT 4: YouTube Link Finder
- Name: YouTube Link Finder
- Final Output: YouTube link for each matching song
- Tasks:
  - Search Google (Task 15): Search for each song on YouTube
  - Scrape links from website (Task 17): Obtain video links from YouTube search results
  - GPT4 (Task 1): Analyze video titles, descriptions, and durations to select the most relevant link
  - REQUIRED: Integrate with YouTube API to find the most relevant videos for the songs
- Sequence: Receive list of matching songs and extracted information > Search for each song on YouTube using Google Search (Task 15) > Scrape video links from YouTube search results (Task 17) > Analyze videos using GPT4 to select the most relevant link > Integrate with YouTube API (REQUIRED) for more precise video retrieval > Store YouTube link for each song > Output YouTube links

I) SUBAGENT 5: Output Generator
- Name: Output Generator
- Final Output: Structured JSON file containing song information and YouTube links
- Tasks:
  - GPT4 (Task 1): Generate JSON structure and populate with song information and YouTube links
  - Save content to server (Task 9): Save JSON file to server
- Sequence: Receive extracted song information and YouTube links > Generate JSON structure and populate using GPT4 > Format and escape JSON data using GPT4 > Save JSON file to server (Task 9) > Output final JSON file URL

J) SUBAGENT 6: Error Handler
- Name: Error Handler
- Final Output: Error logs and graceful handling of workflow issues
- Tasks:
  - REQUIRED: Monitor workflow execution and capture errors and exceptions
  - GPT4 (Task 1): Generate error reports, notifications, and determine error handling strategies
  - Save content to server (Task 9): Save error logs to server
- Sequence: Monitor workflow execution (REQUIRED) > Capture errors and exceptions (REQUIRED) > Analyze errors and determine handling strategies using GPT4 > Generate error reports and notifications using GPT4 > Save error logs to server (Task 9) > Implement error handling mechanisms > Ensure smooth workflow execution

These subagents, utilizing the available tasks and some required API integrations, will work together to create an automated workflow that takes user input, searches music databases and APIs, extracts song information, retrieves YouTube links, and generates a structured JSON output containing songs suitable for sampling based on the user's criteria. The Error Handler ensures the workflow runs smoothly, handling any issues that may arise during the process.

random-autocomplete

To achieve the end goal of creating a structured document containing a curated list of songs suitable for sampling based on the provided criteria, the most relevant tasks might be:

1. Parsing and understanding the input criteria (key, tempo, style, previous artists, instrumentation)
2. Searching music databases and APIs for songs matching the criteria
3. Extracting relevant information about each song (title, artist, album, year, metadata)
4. Finding YouTube links for each song
5. Compiling the information into a structured document (JSON, CSV, or formatted text)

The overall sequence of actions would be:

1. Parse the input criteria: The Agent would analyze the provided description and extract the relevant information, such as key, tempo, style, previous artists, and desired instrumentation. This step ensures that the Agent understands the user's requirements.

2. Search music databases and APIs: The Agent would use the parsed criteria to search for matching songs across various music databases and APIs. This could involve using APIs like Spotify, Last.fm, or MusicBrainz, as well as web scraping techniques to gather information from websites dedicated to sampling and music discovery.

3. Filter and rank the results: The Agent would apply additional filters and ranking algorithms to narrow down the search results based on relevance and quality. This step ensures that the most suitable songs are selected for the final output.

4. Extract song information: For each selected song, the Agent would extract the necessary information, such as the song title, artist name, album (if applicable), year of release, and any available metadata related to key, tempo, style, and instrumentation.

5. Find YouTube links: The Agent would use the YouTube API or web scraping techniques to search for and retrieve the corresponding YouTube link for each song. This step provides a convenient way for the user to listen to the songs directly.

6. Compile the structured document: Finally, the Agent would compile all the gathered information into a structured document format, such as JSON, CSV, or formatted text. This document would contain a list of songs, with each entry including the song title, artist name, album, year of release, YouTube link, and any additional metadata.

7. Output the result: The Agent would save the structured document and provide it as the final output to the user, either by saving it to a file or returning it as a response to the initial request.

By following this sequence of actions, the AI Agent would be able to process the user's input criteria, search for relevant songs across multiple sources, compile the necessary information, and generate a structured document that provides a curated list of songs suitable for sampling, complete with YouTube links for easy access.

claude 3 - mermaid-for-all

SubAgent #1

claude 3 - subagent1

subagent1-refined

A) SUBAGENT SUMMARY: The Music Database Connector subagent establishes authenticated connections to various music databases and APIs, ready for querying by other subagents.

B) FINAL TASK OUTPUT: A list of authenticated API client objects or connection URLs, each corresponding to a specific music database or API, ready to be used for querying.

C) SUBAGENT INPUT:
- A configuration file (JSON or YAML) containing the following information for each music database or API:
  - API endpoint URL
  - Authentication method (API key, OAuth, etc.)
  - Authentication credentials (API key, client ID, client secret, etc.)
  - Rate limits and usage restrictions
  - Sample query templates

D) SUBAGENT TASK SUMMARY:
1. Read database/API configuration file
   - Task: GPT4 (Task 1)
   - Input: Path to the configuration file (JSON or YAML)
   - Action: Read and parse the configuration file, extracting the necessary information for each database/API
   - Output: Parsed configuration data as a structured object (e.g., dictionary or list)

2. Format query templates for each database/API
   - Task: GPT4 (Task 1)
   - Input: Parsed configuration data from step 1
   - Action: For each database/API, format the provided sample query templates with the appropriate authentication parameters and placeholders for user input
   - Output: Formatted query templates for each database/API

3. Establish authenticated connections (REQUIRED)
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: Parsed configuration data and formatted query templates from steps 1 and 2
   - Action: For each database/API:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client objects or connection URLs for each database/API

4. Store and output authenticated connections
   - Task: GPT4 (Task 1)
   - Input: Authenticated API client objects or connection URLs from step 3
   - Action: Store the authenticated connections in a suitable format (e.g., dictionary, list) and prepare them for use by other subagents
   - Output: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name

E) SILOS:
This subagent does not have any silos, as it focuses on a single responsibility: establishing authenticated connections to music databases and APIs. The subagent's tasks are sequential and interdependent, with each step building upon the previous one to achieve the final output.

subagent1refined-repeating

G) FULL TASKS (INCLUDING REPEATING TASKS):

1. Read database/API configuration file
   - Task: GPT4 (Task 1)
   - Input: Path to the configuration file (JSON or YAML)
   - Action: Read and parse the configuration file, extracting the necessary information for each database/API
   - Output: Parsed configuration data as a structured object (e.g., dictionary or list)

3. Establish authenticated connection for database/API 1
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: Parsed configuration data and formatted query templates for database/API 1
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 1

4. Establish authenticated connection for database/API 2
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: Parsed configuration data and formatted query templates for database/API 2
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 2

5. Establish authenticated connection for database/API 3
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: Parsed configuration data and formatted query templates for database/API 3
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 3

6. Store and output authenticated connections
   - Task: GPT4 (Task 1)
   - Input: Authenticated API client objects or connection URLs from steps 3, 4, and 5
   - Action: Store the authenticated connections in a suitable format (e.g., dictionary, list) and prepare them for use by other subagents
   - Output: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name

Note: The number of "Establish authenticated connection" tasks (steps 3, 4, and 5) will depend on the number of databases/APIs specified in the configuration file. In this example, I assumed there are three databases/APIs, but the actual number may vary based on the configuration.

Subagent1 task-ID-numbers

subagent1-output-variables

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

G) FULL TASKS (INCLUDING REPEATING TASKS):

2. Format query templates for each database/API
   - Task: GPT4 (Task 1)
   - Input: [config-data]
   - Action: For each database/API, format the provided sample query templates with the appropriate authentication parameters and placeholders for user input
   - Output: Formatted query templates for each database/API [query-templates]

3. Establish authenticated connection for database/API 1
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: [config-data], [query-templates]
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 1 [api1-connection]

4. Establish authenticated connection for database/API 2
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: [config-data], [query-templates]
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 2 [api2-connection]

5. Establish authenticated connection for database/API 3
   - Task: Custom API integration task (not listed in the available tasks)
   - Input: [config-data], [query-templates]
   - Action:
     - Initialize the appropriate API client library or create a custom HTTP client
     - Authenticate using the provided credentials and authentication method
     - Test the connection by making a sample request and verifying the response
   - Output: Authenticated API client object or connection URL for database/API 3 [api3-connection]

6. Store and output authenticated connections
   - Task: GPT4 (Task 1)
   - Input: [api1-connection], [api2-connection], [api3-connection]
   - Action: Store the authenticated connections in a suitable format (e.g., dictionary, list) and prepare them for use by other subagents
   - Output: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name [authenticated-connections]

H) OUTPUT TOKENS

- [config-data]: Parsed configuration data as a structured object (e.g., dictionary or list)
- [query-templates]: Formatted query templates for each database/API
- [api1-connection]: Authenticated API client object or connection URL for database/API 1
- [api2-connection]: Authenticated API client object or connection URL for database/API 2
- [api3-connection]: Authenticated API client object or connection URL for database/API 3
- [authenticated-connections]: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name

subagent1refined-repeating-json-core

A) SUBAGENT SUMMARY: Configure and establish authenticated connections to multiple databases/APIs for querying music samples.

B) FINAL TASK OUTPUT: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name, ready for use by other subagents to query music samples.

C) SUBAGENT INPUT:
- Path to the configuration file (JSON or YAML) containing database/API settings and sample query templates
- List of database/API names to establish connections for

E) SUBAGENT TASK SUMMARY:
1. Read and parse the configuration file to extract necessary information for each database/API.
2. Format query templates for each database/API with appropriate authentication parameters and placeholders for user input.
3. For each database/API:
   - Initialize the appropriate API client library or create a custom HTTP client
   - Authenticate using the provided credentials and authentication method
   - Test the connection by making a sample request and verifying the response
4. Store the authenticated connections in a suitable format and prepare them for use by other subagents.

F) SILOS: N/A

G) TASKFLOW SUMMARY:

Task 1:
Title task: Read and parse database/API configuration file
Description of the task: Read the provided configuration file (JSON or YAML) and extract the necessary information for each database/API, such as authentication credentials, endpoints, and sample query templates.
Input(s) involved: Path to the configuration file (JSON or YAML)
Output token name: Parsed configuration data as a structured object (e.g., dictionary or list)

Task 2:
Title task: Format query templates for each database/API
Description of the task: For each database/API specified in the parsed configuration data, format the provided sample query templates with the appropriate authentication parameters and placeholders for user input.
Input(s) involved: Parsed configuration data from Task 1
Output token name: Formatted query templates for each database/API

Task 3:
Title task: Establish authenticated connection for database/API 1
Description of the task: Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 1.
Input(s) involved: Parsed configuration data and formatted query templates for database/API 1
Output token name: Authenticated API client object or connection URL for database/API 1

Task 4:
Title task: Establish authenticated connection for database/API 2
Description of the task: Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 2.
Input(s) involved: Parsed configuration data and formatted query templates for database/API 2
Output token name: Authenticated API client object or connection URL for database/API 2

Task 5:
Title task: Establish authenticated connection for database/API 3
Description of the task: Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 3.
Input(s) involved: Parsed configuration data and formatted query templates for database/API 3
Output token name: Authenticated API client object or connection URL for database/API 3

Task 6:
Title task: Store and output authenticated connections
Description of the task: Store the authenticated connections obtained from Tasks 3, 4, and 5 in a suitable format (e.g., dictionary, list) and prepare them for use by other subagents, labeling each connection with the corresponding database/API name.
Input(s) involved: Authenticated API client objects or connection URLs from Tasks 3, 4, and 5
Output token name: List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name

subagent1mermaid

<!DOCTYPE html>
<html>
<head>
  <title>Mermaid Diagram Example</title>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/mermaid/9.4.3/mermaid.min.js"></script>
</head>
<body>
  <div class="mermaid">
graph TD
    A[Read and parse database/API configuration file] -->|Parsed configuration data| B[Format query templates for each database/API]
    B -->|Parsed configuration data and formatted query templates| C{Establish authenticated connections}
    C -->|For database/API 1| D[Establish authenticated connection for database/API 1]
    C -->|For database/API 2| E[Establish authenticated connection for database/API 2]
    C -->|For database/API 3| F[Establish authenticated connection for database/API 3]
    D -->|Authenticated API client object or connection URL| G[Store and output authenticated connections]
    E -->|Authenticated API client object or connection URL| G
    F -->|Authenticated API client object or connection URL| G
    G -->|List of authenticated API client objects or connection URLs| H{Output}
  </div>

SubAgent #2

claude 3 - subagent2

- Name: Music Sampler
- Final Output: List of songs that match the user's sampling criteria
- Tasks:
  - GPT4 (Task 1): Interpret user's input criteria and generate search queries
  - Search Google (Task 15): Find relevant music databases and APIs
  - Scrape text content of website (Task 16): Gather song information from identified websites
  - GPT4 (Task 1): Analyze scraped content and identify relevant songs based on user's criteria
  - REQUIRED: Execute queries on databases/APIs, handle pagination, and parse results
  - GPT4 (Task 1): Apply filtering and ranking algorithms to refine search results
- Sequence: Receive structured input data and authenticated connections > Interpret user's criteria and generate search queries using GPT4 > Find relevant databases and APIs using Google Search > Scrape song information from websites > Analyze scraped content and identify relevant songs using GPT4 > Execute queries on databases/APIs (REQUIRED) > Handle pagination and parse results (REQUIRED) > Apply filtering and ranking algorithms using GPT4 > Output list of matching songs

subagent2-refined

A) SUBAGENT SUMMARY: The Music Sampler subagent searches for songs that match the user's specified sampling criteria by querying music databases, APIs, and websites, and outputs a curated list of matching songs.

B) FINAL TASK OUTPUT: A JSON file containing an array of song objects, where each object includes the song title, artist name, album (if applicable), year of release, and additional metadata such as key, tempo, style, and instrumentation. The file size will depend on the number of matching songs found but is expected to be under 1 MB.

C) SUBAGENT INPUT:
- Structured JSON data containing the user's sampling criteria (e.g., key, tempo, style, previous artists, desired instrumentation)
- Authenticated connections to music databases and APIs (provided by the Music Database Connector subagent)

E) SUBAGENT TASK SUMMARY:
1. Receive structured JSON input data and authenticated database/API connections
2. Use GPT4 (Task 1) to interpret the user's input criteria and generate search queries
3. Search Google (Task 15) to find relevant music databases and APIs
4. Scrape text content of websites (Task 16) to gather song information from identified sources
5. Use GPT4 (Task 1) to analyze scraped content and identify songs that potentially match the user's criteria
6. Execute queries on the authenticated databases and APIs (REQUIRED)
7. Handle pagination and parse the query results (REQUIRED)
8. Use GPT4 (Task 1) to apply filtering and ranking algorithms to refine the search results
9. Generate a JSON file containing the curated list of matching songs
10. Save the JSON file to the server (Task 9)
11. Output the URL of the saved JSON file

F) SILOS:
Silo 1: Query Execution
- Execute queries on the authenticated databases and APIs (REQUIRED)
- Handle pagination and parse the query results (REQUIRED)

Silo 2: Song Information Gathering
- Search Google (Task 15) to find relevant music databases and APIs
- Scrape text content of websites (Task 16) to gather song information from identified sources

Silo 3: Result Refinement
- Use GPT4 (Task 1) to analyze scraped content and identify songs that potentially match the user's criteria
- Use GPT4 (Task 1) to apply filtering and ranking algorithms to refine the search results

Silo 4: Output Generation
- Generate a JSON file containing the curated list of matching songs
- Save the JSON file to the server (Task 9)
- Output the URL of the saved JSON file

subagent2refined-repeating

F) SILOS:
Silo 1: Query Execution
- Execute queries on the authenticated databases and APIs (REQUIRED)
- Handle pagination and parse the query results (REQUIRED)

Silo 2: Song Information Gathering
- Search Google (Task 15) to find relevant music databases and APIs
- Scrape text content of websites (Task 16) to gather song information from identified sources

Silo 4: Output Generation
- Generate a JSON file containing the curated list of matching songs
- Save the JSON file to the server (Task 9)
- Output the URL of the saved JSON file

G) FULL TASKS (INCLUDING REPEATING TASKS):
1. Receive structured JSON input data containing the user's sampling criteria
2. Receive authenticated connections to music databases and APIs from the Music Database Connector subagent
3. Use GPT4 (Task 1) to interpret the user's input criteria and generate search queries
4. Search Google (Task 15) to find 5 relevant music databases and APIs
5. Scrape text content of websites (Task 16) for each of the 5 identified sources to gather song information
6. Use GPT4 (Task 1) to analyze scraped content from the 5 sources and identify songs that potentially match the user's criteria
7. Execute queries on the authenticated databases and APIs for each of the 5 sources (REQUIRED)
8. Handle pagination and parse the query results for each of the 5 sources (REQUIRED)
9. Use GPT4 (Task 1) to apply filtering and ranking algorithms to refine the search results from the 5 sources
10. Combine the refined search results from the 5 sources into a single list
11. Generate a JSON file containing the curated list of matching songs
12. Save the JSON file to the server (Task 9)
13. Output the URL of the saved JSON file

Subagent2 task-ID-numbers

subagent2-output-variables

Here is the updated task list with output tokens:

E) SUBAGENT TASK SUMMARY:
1. Receive structured JSON input data and authenticated database/API connections
2. Use GPT4 (Task 1) to interpret the user's input criteria and generate search queries [search-queries]
3. Search Google (Task 15) to find relevant music databases and APIs [music-databases-apis]
4. Scrape text content of websites (Task 16) to gather song information from identified sources [scraped-song-info]
5. Use GPT4 (Task 1) to analyze scraped content and identify songs that potentially match the user's criteria [potential-matches]
6. Execute queries on the authenticated databases and APIs (REQUIRED) [query-results]
7. Handle pagination and parse the query results (REQUIRED) [parsed-query-results]
8. Use GPT4 (Task 1) to apply filtering and ranking algorithms to refine the search results [refined-results]
9. Generate a JSON file containing the curated list of matching songs [song-list-json]
10. Save the JSON file to the server (Task 9) [saved-json-url]
11. Output the URL of the saved JSON file

F) SILOS:
Silo 1: Query Execution
- Execute queries on the authenticated databases and APIs (REQUIRED)
- Handle pagination and parse the query results (REQUIRED)

Silo 2: Song Information Gathering
- Search Google (Task 15) to find relevant music databases and APIs
- Scrape text content of websites (Task 16) to gather song information from identified sources

Silo 4: Output Generation
- Generate a JSON file containing the curated list of matching songs
- Save the JSON file to the server (Task 9)
- Output the URL of the saved JSON file

G) FULL TASKS (INCLUDING REPEATING TASKS):
1. Receive structured JSON input data containing the user's sampling criteria [user-criteria]
2. Receive authenticated connections to music databases and APIs from the Music Database Connector subagent [db-api-connections]
3. Use GPT4 (Task 1) to interpret the user's input criteria and generate search queries [search-queries]
4. Search Google (Task 15) to find 5 relevant music databases and APIs [music-databases-apis1] to [music-databases-apis5]
5. Scrape text content of websites (Task 16) for each of the 5 identified sources to gather song information [scraped-song-info1] to [scraped-song-info5]
6. Use GPT4 (Task 1) to analyze scraped content from the 5 sources and identify songs that potentially match the user's criteria [potential-matches1] to [potential-matches5]
7. Execute queries on the authenticated databases and APIs for each of the 5 sources (REQUIRED) [query-results1] to [query-results5]
8. Handle pagination and parse the query results for each of the 5 sources (REQUIRED) [parsed-query-results1] to [parsed-query-results5]
9. Use GPT4 (Task 1) to apply filtering and ranking algorithms to refine the search results from the 5 sources [refined-results1] to [refined-results5]
10. Combine the refined search results from the 5 sources into a single list [combined-refined-results]
11. Generate a JSON file containing the curated list of matching songs [song-list-json]
12. Save the JSON file to the server (Task 9) [saved-json-url]
13. Output the URL of the saved JSON file

H) OUTPUT TOKENS:
- [user-criteria]
- [db-api-connections]
- [search-queries]
- [music-databases-apis1] to [music-databases-apis5]
- [scraped-song-info1] to [scraped-song-info5]
- [potential-matches1] to [potential-matches5]
- [query-results1] to [query-results5]
- [parsed-query-results1] to [parsed-query-results5]
- [refined-results1] to [refined-results5]
- [combined-refined-results]
- [song-list-json]
- [saved-json-url]

subagent2refined-repeating-json-core

G) TASKFLOW SUMMARY

Title task: Receive and interpret user's sampling criteria
Description of the task: Receive structured JSON input data containing the user's sampling criteria and use GPT4 to interpret the criteria and generate search queries.
Input(s) involved: [user_sampling_criteria_json]
Output token name: [interpreted_sampling_criteria]

Title task: Receive authenticated database and API connections
Description of the task: Receive authenticated connections to music databases and APIs from the Music Database Connector subagent.
Input(s) involved: [authenticated_database_connections], [authenticated_api_connections]
Output token name: [database_api_connections]

Title task: Search for relevant music databases and APIs
Description of the task: Search Google to find 5 relevant music databases and APIs based on the interpreted sampling criteria.
Input(s) involved: [interpreted_sampling_criteria]
Output token name: [relevant_music_sources]

Title task: Scrape song information from identified sources
Description of the task: Scrape text content of websites for each of the 5 identified sources to gather song information.
Input(s) involved: [relevant_music_sources]
Output token name: [scraped_song_info]

Title task: Analyze scraped content to identify potential matches
Description of the task: Use GPT4 to analyze scraped content from the 5 sources and identify songs that potentially match the user's criteria.
Input(s) involved: [scraped_song_info], [interpreted_sampling_criteria]
Output token name: [potential_song_matches]

Title task: Execute queries on databases and APIs
Description of the task: Execute queries on the authenticated databases and APIs for each of the 5 sources to retrieve song information.
Input(s) involved: [database_api_connections], [relevant_music_sources]
Output token name: [query_results]

Title task: Handle pagination and parse query results
Description of the task: Handle pagination and parse the query results for each of the 5 sources to extract relevant song information.
Input(s) involved: [query_results]
Output token name: [parsed_song_info]

Title task: Refine search results using filtering and ranking
Description of the task: Use GPT4 to apply filtering and ranking algorithms to refine the search results from the 5 sources based on the user's criteria.
Input(s) involved: [parsed_song_info], [potential_song_matches], [interpreted_sampling_criteria]
Output token name: [refined_search_results]

Title task: Combine refined search results into a single list
Description of the task: Combine the refined search results from the 5 sources into a single list of matching songs.
Input(s) involved: [refined_search_results]
Output token name: [combined_song_list]

Title task: Generate JSON file with curated song list
Description of the task: Generate a JSON file containing the curated list of matching songs, including relevant metadata for each song.
Input(s) involved: [combined_song_list]
Output token name: [song_list_json]

Title task: Save JSON file to server
Description of the task: Save the generated JSON file containing the curated song list to the server.
Input(s) involved: [song_list_json]
Output token name: [saved_json_url]

Title task: Output URL of saved JSON file
Description of the task: Output the URL of the saved JSON file containing the curated list of matching songs.
Input(s) involved: [saved_json_url]
Output token name: [output_json_url]

subagent2mermaid

<!DOCTYPE html>
<html>
<head>
  <title>Mermaid Diagram Example</title>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/mermaid/9.4.3/mermaid.min.js"></script>
</head>
<body>
  <div class="mermaid">
graph TD
    A[Receive and interpret user's sampling criteria] -->|interpreted_sampling_criteria| C{Search for relevant music databases and APIs}
    A -->|interpreted_sampling_criteria| F{Analyze scraped content to identify potential matches}
    A -->|interpreted_sampling_criteria| I{Refine search results using filtering and ranking}
    B[Receive authenticated database and API connections] -->|database_api_connections| G{Execute queries on databases and APIs}
    C -->|relevant_music_sources| D{Scrape song information from identified sources}
    C -->|relevant_music_sources| G
    D -->|scraped_song_info| F
    F -->|potential_song_matches| I
    G -->|query_results| H{Handle pagination and parse query results}
    H -->|parsed_song_info| I
    I -->|refined_search_results| J{Combine refined search results into a single list}
    J -->|combined_song_list| K[Generate JSON file with curated song list]
    K -->|song_list_json| L[Save JSON file to server]
    L -->|saved_json_url| M[Output URL of saved JSON file]
  </div>

SubAgent #3

claude 3 - subagent3

subagent1-refined

A) SUBAGENT SUMMARY: The Song Info Extractor subagent extracts relevant song information (title, artist, album, year, metadata) for each matching song from the list provided by the Music Sampler subagent.

B) FINAL TASK OUTPUT: A structured data format (e.g., JSON or XML) containing the extracted song information for each matching song, including the following fields:
- Song title (string)
- Artist name (string)
- Album name (string, if applicable)
- Year of release (integer)
- Additional metadata (e.g., key, tempo, style, instrumentation) (string or numeric values, depending on the metadata type)

C) SUBAGENT INPUT: A list of matching songs obtained from the Music Sampler subagent, containing the following information for each song:
- Unique song identifier (e.g., ID from the music database or API)
- Source of the song information (e.g., database name, API name, or website URL)

E) SUBAGENT TASK SUMMARY:
1. Receive the list of matching songs from the Music Sampler subagent.
2. For each song in the list:
   a. Extract the unique song identifier and source information.
   b. If the source is a website:
      i. Use Task 16 (Scrape text content of website) to extract the song information from the website.
      ii. Use Task 1 (GPT4) to parse the scraped text and extract the relevant song information (title, artist, album, year, metadata).
   c. If the source is a musical database or API:
      i. Use the REQUIRED task (Extract structured song metadata from musical databases or APIs) to retrieve the song information using the unique song identifier.
   d. Store the extracted song information in a structured format (e.g., JSON or XML).
3. Use Task 1 (GPT4) to process and organize the extracted song information, ensuring consistency and completeness.
4. Output the final structured data containing the extracted song information for all matching songs.

F) SILOS:
Silo 1: Web Scraping
- Extract song information from websites using Task 16 (Scrape text content of website)
- Parse scraped text using Task 1 (GPT4) to extract relevant song information

Silo 2: Musical Database and API Integration
- Extract structured song metadata from musical databases or APIs using the REQUIRED task
- Store the extracted song information in a structured format

Silo 3: Data Processing and Organization
- Process and organize the extracted song information using Task 1 (GPT4)
- Ensure consistency and completeness of the extracted data
- Output the final structured data containing the extracted song information for all matching songs

subagent1refined-repeating

Here is the updated subagent task summary with the additional section G) FULL TASKS (INCLUDING REPEATING TASKS):

F) SILOS:
Silo 1: Web Scraping
- Extract song information from websites using Task 16 (Scrape text content of website)
- Parse scraped text using Task 1 (GPT4) to extract relevant song information

Silo 2: Musical Database and API Integration
- Extract structured song metadata from musical databases or APIs using the REQUIRED task
- Store the extracted song information in a structured format

G) FULL TASKS (INCLUDING REPEATING TASKS):
1. Receive the list of matching songs from the Music Sampler subagent.
2. For each song in the list (assuming N songs):
   a. Extract the unique song identifier and source information.
   b. If the source is a website:
      i. Use Task 16 (Scrape text content of website) to extract the song information from the website.
      ii. Use Task 1 (GPT4) to parse the scraped text and extract the relevant song information (title, artist, album, year, metadata).
   c. If the source is a musical database or API:
      i. Use the REQUIRED task (Extract structured song metadata from musical databases or APIs) to retrieve the song information using the unique song identifier.
   d. Store the extracted song information in a structured format (e.g., JSON or XML).
3. Use Task 1 (GPT4) to process and organize the extracted song information for all N songs, ensuring consistency and completeness.
4. Output the final structured data containing the extracted song information for all N matching songs.

In this case, the main repeating task is the extraction of song information for each song in the list of N matching songs. This involves either web scraping or API integration, depending on the source of the song information. The data processing and organization task (Task 1 - GPT4) is also applied to all N songs to ensure consistency and completeness of the extracted data.

Subagent1 task-ID-numbers3

subagent3-output-variables

Here is the updated subagent task summary with the additional section H) OUTPUT TOKENS:

F) SILOS:
Silo 1: Web Scraping
- Extract song information from websites using Task 16 (Scrape text content of website)
- Parse scraped text using Task 1 (GPT4) to extract relevant song information

Silo 2: Musical Database and API Integration
- Extract structured song metadata from musical databases or APIs using the REQUIRED task
- Store the extracted song information in a structured format

G) FULL TASKS (INCLUDING REPEATING TASKS):
1. Receive the list of matching songs from the Music Sampler subagent [matching-songs-list].
2. For each song in the list (assuming N songs):
   a. Extract the unique song identifier [song-id-n] and source information [song-source-n].
   b. If the source is a website:
      i. Use Task 16 (Scrape text content of website) to extract the song information from the website [scraped-song-info-n].
      ii. Use Task 1 (GPT4) to parse the scraped text and extract the relevant song information (title, artist, album, year, metadata) [parsed-song-info-n].
   c. If the source is a musical database or API:
      i. Use the REQUIRED task (Extract structured song metadata from musical databases or APIs) to retrieve the song information using the unique song identifier [api-song-info-n].
   d. Store the extracted song information in a structured format (e.g., JSON or XML) [structured-song-info-n].
3. Use Task 1 (GPT4) to process and organize the extracted song information for all N songs, ensuring consistency and completeness [processed-song-info].
4. Output the final structured data containing the extracted song information for all N matching songs [final-song-info].

H) OUTPUT TOKENS:
- [matching-songs-list]: The list of matching songs received from the Music Sampler subagent.
- [song-id-n]: The unique song identifier for the nth song in the list.
- [song-source-n]: The source information for the nth song in the list.
- [scraped-song-info-n]: The scraped song information from the website for the nth song.
- [parsed-song-info-n]: The parsed song information extracted from the scraped text for the nth song.
- [api-song-info-n]: The song information retrieved from the musical database or API for the nth song.
- [structured-song-info-n]: The extracted song information for the nth song stored in a structured format.
- [processed-song-info]: The processed and organized song information for all N songs.
- [final-song-info]: The final structured data containing the extracted song information for all N matching songs.

subagent3refined-repeating-json-core

G) TASKFLOW SUMMARY

Title task: Extract unique song identifier and source information
Description of the task: Extract the unique song identifier and source information (website or musical database/API) for each song in the list of matching songs provided by the Music Sampler subagent.
Input(s) involved: [list_of_matching_songs]
Output token name: [song_identifier_and_source]

Title task: Scrape song information from website
Description of the task: Use Task 16 (Scrape text content of website) to extract the song information from the website if the source is a website.
Input(s) involved: [song_identifier_and_source]
Output token name: [scraped_song_info]

Title task: Parse scraped text to extract song information
Description of the task: Use Task 1 (GPT4) to parse the scraped text and extract the relevant song information (title, artist, album, year, metadata) if the source is a website.
Input(s) involved: [scraped_song_info]
Output token name: [extracted_song_info]

Title task: Extract structured song metadata from musical databases or APIs
Description of the task: Use the REQUIRED task (Extract structured song metadata from musical databases or APIs) to retrieve the song information using the unique song identifier if the source is a musical database or API.
Input(s) involved: [song_identifier_and_source]
Output token name: [extracted_song_info]

Title task: Store extracted song information in structured format
Description of the task: Store the extracted song information in a structured format (e.g., JSON or XML) for each song in the list of matching songs.
Input(s) involved: [extracted_song_info]
Output token name: [structured_song_info]

Title task: Process and organize extracted song information
Description of the task: Use Task 1 (GPT4) to process and organize the extracted song information for all matching songs, ensuring consistency and completeness of the extracted data.
Input(s) involved: [structured_song_info]
Output token name: [processed_song_info]

Title task: Output final structured data containing extracted song information
Description of the task: Output the final structured data containing the extracted song information for all matching songs in the specified format (e.g., JSON or XML).
Input(s) involved: [processed_song_info]
Output token name: [final_song_info_output]

subagent3mermaid

prompts-required

Based on the provided components, here are the unique prompts that need to be written for the AI agent workflow:

Task: Interpret User Input
Output of the task: Structured query parameters (e.g., JSON, YAML) representing the user's sampling criteria
Description:
- Develop a prompt that guides the user to provide their sampling criteria in a conversational manner.
- The prompt should ask the user to specify details such as key, tempo, style, previous artists who sampled it, and desired instrumentation.
- The LLM should interpret the user's input using natural language processing and machine learning techniques.
- The output should be a structured set of query parameters that can be used to search music/sample databases and APIs.

Task: Generate Search Queries
Output of the task: Specific search queries for each music/sample database and API
Description:
- Create a prompt that takes the structured query parameters from the previous task as input.
- The prompt should guide the LLM to generate specific search queries for each music/sample database and API based on the input criteria.
- The LLM should consider the syntax, format, and capabilities of each database and API when generating the search queries.
- The output should be a set of search queries tailored to each database and API.

Task: Refine Search Results
Output of the task: Filtered list of songs that closely match the user's criteria
Description:
- Develop a prompt that takes the search results from multiple databases and APIs as input.
- The prompt should instruct the LLM to analyze the search results and filter them based on the user's input criteria.
- The LLM should apply techniques such as keyword matching, musical feature analysis, and machine learning models to identify the most relevant songs.
- The output should be a refined list of songs that closely match the user's sampling requirements.

Task: Extract Song Information
Output of the task: Structured song information (title, artist, album, year, metadata) for each song in the refined list
Description:
- Create a prompt that guides the LLM to extract relevant song information from the refined list of songs.
- The prompt should specify the required information fields, such as song title, artist name, album, year of release, and any additional metadata.
- The LLM should use techniques like web scraping, API response parsing, or HTML/JSON/XML parsing to extract the song information accurately.
- The output should be a structured dataset containing the extracted song information for each song.

Task: Retrieve YouTube Links
Output of the task: YouTube video links for each song in the dataset
Description:
- Develop a prompt that instructs the LLM to search for and retrieve the most relevant YouTube video link for each song in the dataset.
- The prompt should guide the LLM to use the YouTube API or web scraping techniques to find the best match for each song.
- The LLM should handle scenarios where multiple video results are available and select the most appropriate one based on relevance and quality.
- The output should be an updated dataset that includes the retrieved YouTube links for each song.

Task: Generate Final Output
Output of the task: Structured document (JSON, CSV, or formatted text) containing the curated list of songs with all relevant information and YouTube links
Description:
- Create a prompt that guides the LLM to generate the final output document based on the updated dataset.
- The prompt should specify the desired format (JSON, CSV, or formatted text) and the structure of the output document.
- The LLM should organize the song information, metadata, and YouTube links into a readable and structured format.
- The output should be a final document that represents the curated list of songs matching the user's sampling criteria, along with the corresponding YouTube links.

These prompts cover the main components of the AI agent workflow. Additional prompts may be needed for error handling, logging, and any specific formatting or enhancement requirements based on the user's preferences and the capabilities of the LLM and external APIs/databases.

subagent1-json-array

[
  {
    "task ID": 1,
    "title of the task": "Read and parse database/API configuration file",
    "description of the task": "Read the provided configuration file (JSON or YAML) and extract the necessary information for each database/API, such as authentication credentials, endpoints, and sample query templates.",
    "input description": "Path to the configuration file (JSON or YAML) containing database/API settings and sample query templates.",
    "input required": [],
    "output description": "Parsed configuration data as a structured object (e.g., dictionary or list) containing the necessary information for each database/API.",
    "output name": "parsed-config-data"
  },
  {
    "task ID": 2,
    "title of the task": "Format query templates for each database/API",
    "description of the task": "For each database/API specified in the parsed configuration data, format the provided sample query templates with the appropriate authentication parameters and placeholders for user input.",
    "input description": "Parsed configuration data from Task 1, containing the necessary information for each database/API.",
    "input required": ["parsed-config-data"],
    "output description": "Formatted query templates for each database/API, with the appropriate authentication parameters and placeholders for user input.",
    "output name": "formatted-query-templates"
  },
  {
    "task ID": 3,
    "title of the task": "Establish authenticated connection for database/API 1",
    "description of the task": "Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 1.",
    "input description": "Parsed configuration data and formatted query templates for database/API 1, containing the necessary information for authentication and connection.",
    "input required": ["parsed-config-data", "formatted-query-templates"],
    "output description": "Authenticated API client object or connection URL for database/API 1, ready for use by other subagents to query music samples.",
    "output name": "authenticated-connection-1"
  },
  {
    "task ID": 4,
    "title of the task": "Establish authenticated connection for database/API 2",
    "description of the task": "Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 2.",
    "input description": "Parsed configuration data and formatted query templates for database/API 2, containing the necessary information for authentication and connection.",
    "input required": ["parsed-config-data", "formatted-query-templates"],
    "output description": "Authenticated API client object or connection URL for database/API 2, ready for use by other subagents to query music samples.",
    "output name": "authenticated-connection-2"
  },
  {
    "task ID": 5,
    "title of the task": "Establish authenticated connection for database/API 3",
    "description of the task": "Initialize the appropriate API client library or create a custom HTTP client, authenticate using the provided credentials and authentication method, and test the connection by making a sample request and verifying the response for database/API 3.",
    "input description": "Parsed configuration data and formatted query templates for database/API 3, containing the necessary information for authentication and connection.",
    "input required": ["parsed-config-data", "formatted-query-templates"],
    "output description": "Authenticated API client object or connection URL for database/API 3, ready for use by other subagents to query music samples.",
    "output name": "authenticated-connection-3"
  },
  {
    "task ID": 6,
    "title of the task": "Store and output authenticated connections",
    "description of the task": "Store the authenticated connections obtained from Tasks 3, 4, and 5 in a suitable format (e.g., dictionary, list) and prepare them for use by other subagents, labeling each connection with the corresponding database/API name.",
    "input description": "Authenticated API client objects or connection URLs from Tasks 3, 4, and 5, each representing a successfully authenticated connection to a specific database/API.",
    "input required": ["authenticated-connection-1", "authenticated-connection-2", "authenticated-connection-3"],
    "output description": "List of authenticated API client objects or connection URLs, each labeled with the corresponding database/API name, ready for use by other subagents to query music samples.",
    "output name": "authenticated-connections-list"
  }
]

subagent1-json-array-mermaid

subagent2-json-array

[
  {
    "task ID": 1,
    "title of the task": "Receive and interpret user's sampling criteria",
    "description of the task": "Receive structured JSON input data containing the user's sampling criteria and use GPT4 to interpret the criteria and generate search queries.",
    "input description": "A JSON file containing the user's sampling criteria, such as key, tempo, style, previous artists who sampled it, and desired instrumentation.",
    "input required": ["[user_sampling_criteria_json]"],
    "output description": "The interpreted user's sampling criteria, including generated search queries based on the input data.",
    "output name": "[interpreted_sampling_criteria]"
  },
  {
    "task ID": 2,
    "title of the task": "Receive authenticated database and API connections",
    "description of the task": "Receive authenticated connections to music databases and APIs from the Music Database Connector subagent.",
    "input description": "Authenticated connections to relevant music databases and APIs, provided by the Music Database Connector subagent.",
    "input required": ["[authenticated_database_connections]", "[authenticated_api_connections]"],
    "output description": "The received authenticated connections to music databases and APIs, ready for use in subsequent tasks.",
    "output name": "[database_api_connections]"
  },
  {
    "task ID": 3,
    "title of the task": "Search for relevant music databases and APIs",
    "description of the task": "Search Google to find 5 relevant music databases and APIs based on the interpreted sampling criteria.",
    "input description": "The interpreted user's sampling criteria, including generated search queries.",
    "input required": ["[interpreted_sampling_criteria]"],
    "output description": "A list of 5 relevant music databases and APIs that match the user's sampling criteria.",
    "output name": "[relevant_music_sources]"
  },
  {
    "task ID": 4,
    "title of the task": "Scrape song information from identified sources",
    "description of the task": "Scrape text content of websites for each of the 5 identified sources to gather song information.",
    "input description": "The list of 5 relevant music databases and APIs identified in the previous task.",
    "input required": ["[relevant_music_sources]"],
    "output description": "Scraped song information from the websites of the 5 identified music sources.",
    "output name": "[scraped_song_info]"
  },
  {
    "task ID": 5,
    "title of the task": "Analyze scraped content to identify potential matches",
    "description of the task": "Use GPT4 to analyze scraped content from the 5 sources and identify songs that potentially match the user's criteria.",
    "input description": "Scraped song information from the 5 sources and the interpreted user's sampling criteria.",
    "input required": ["[scraped_song_info]", "[interpreted_sampling_criteria]"],
    "output description": "A list of songs that potentially match the user's sampling criteria, based on the analysis of the scraped content.",
    "output name": "[potential_song_matches]"
  },
  {
    "task ID": 6,
    "title of the task": "Execute queries on databases and APIs",
    "description of the task": "Execute queries on the authenticated databases and APIs for each of the 5 sources to retrieve song information.",
    "input description": "Authenticated connections to music databases and APIs, and the list of 5 relevant music sources.",
    "input required": ["[database_api_connections]", "[relevant_music_sources]"],
    "output description": "Query results containing song information from the authenticated databases and APIs for each of the 5 sources.",
    "output name": "[query_results]"
  },
  {
    "task ID": 7,
    "title of the task": "Handle pagination and parse query results",
    "description of the task": "Handle pagination and parse the query results for each of the 5 sources to extract relevant song information.",
    "input description": "Query results containing song information from the authenticated databases and APIs for each of the 5 sources.",
    "input required": ["[query_results]"],
    "output description": "Parsed song information extracted from the query results, handling pagination for each of the 5 sources.",
    "output name": "[parsed_song_info]"
  },
  {
    "task ID": 8,
    "title of the task": "Refine search results using filtering and ranking",
    "description of the task": "Use GPT4 to apply filtering and ranking algorithms to refine the search results from the 5 sources based on the user's criteria.",
    "input description": "Parsed song information, potential song matches, and the interpreted user's sampling criteria.",
    "input required": ["[parsed_song_info]", "[potential_song_matches]", "[interpreted_sampling_criteria]"],
    "output description": "Refined search results from the 5 sources, filtered and ranked based on the user's sampling criteria.",
    "output name": "[refined_search_results]"
  },
  {
    "task ID": 9,
    "title of the task": "Combine refined search results into a single list",
    "description of the task": "Combine the refined search results from the 5 sources into a single list of matching songs.",
    "input description": "Refined search results from the 5 sources, filtered and ranked based on the user's sampling criteria.",
    "input required": ["[refined_search_results]"],
    "output description": "A single, combined list of songs that match the user's sampling criteria, derived from the refined search results.",
    "output name": "[combined_song_list]"
  },
  {
    "task ID": 10,
    "title of the task": "Generate JSON file with curated song list",
    "description of the task": "Generate a JSON file containing the curated list of matching songs, including relevant metadata for each song.",
    "input description": "The combined list of songs that match the user's sampling criteria.",
    "input required": ["[combined_song_list]"],
    "output description": "A JSON file containing the curated list of matching songs, with relevant metadata for each song.",
    "output name": "[song_list_json]"
  },
  {
    "task ID": 11,
    "title of the task": "Save JSON file to server",
    "description of the task": "Save the generated JSON file containing the curated song list to the server.",
    "input description": "The JSON file containing the curated list of matching songs, with relevant metadata for each song.",
    "input required": ["[song_list_json]"],
    "output description": "The URL of the saved JSON file on the server.",
    "output name": "[saved_json_url]"
  },
  {
    "task ID": 12,
    "title of the task": "Output URL of saved JSON file",
    "description of the task": "Output the URL of the saved JSON file containing the curated list of matching songs.",
    "input description": "The URL of the saved JSON file on the server.",
    "input required": ["[saved_json_url]"],
    "output description": "The URL of the saved JSON file containing the curated list of matching songs, ready for use by other subagents or the main workflow.",
    "output name": "[output_json_url]"
  }
]

Sample Finder

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

final-output-comps..1

final-output-comps..2

final-output-comps GPT..3

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

claude 3 - extract final output

extract component outputs

Claude - research-ideas-and-input-variables

GPT - research-ideas-and-input-variables

template-ideas

claude 3 - searches

subagent-summary

subagent-summary-amended-for-actual-tasks..1

subagent-summary-amended-for-actual-tasks..2

subagent-summary-amended-for-actual-tasks GPT..3

subagent-summary-amended-for-actual-tasks

random-autocomplete

claude 3 - mermaid-for-all

SubAgent #1

claude 3 - subagent1

subagent1-refined

subagent1refined-repeating

Subagent1 task-ID-numbers

subagent1-output-variables

subagent1refined-repeating-json-core

subagent1mermaid

SubAgent #2

claude 3 - subagent2

subagent2-refined

subagent2refined-repeating

Subagent2 task-ID-numbers

subagent2-output-variables

subagent2refined-repeating-json-core

subagent2mermaid

SubAgent #3

claude 3 - subagent3

subagent1-refined

subagent1refined-repeating

Subagent1 task-ID-numbers3

subagent3-output-variables

subagent3refined-repeating-json-core

subagent3mermaid

prompts-required

subagent1-json-array

subagent1-json-array-mermaid

subagent2-json-array

subagent2-json-array-mermaid